dist/ember.js in ember-source-2.3.2 vs dist/ember.js in ember-source-2.4.0.beta.2

- old
+ new

@@ -4,11 +4,11 @@ * @copyright Copyright 2011-2015 Tilde Inc. and contributors * Portions Copyright 2006-2011 Strobe Inc. * Portions Copyright 2008-2011 Apple Inc. All rights reserved. * @license Licensed under MIT license * See https://raw.github.com/emberjs/ember.js/master/LICENSE - * @version 2.3.2 + * @version 2.4.0-beta.2 */ var enifed, requireModule, require, requirejs, Ember; var mainContext = this; @@ -41,34 +41,47 @@ }; requirejs = require = requireModule = function(name) { return internalRequire(name, null); } + + // setup `require` module require['default'] = require; + require.has = function registryHas(moduleName) { + return !!registry[moduleName] || !!registry[moduleName + '/index']; + }; + function missingModule(name, referrerName) { if (referrerName) { throw new Error('Could not find module ' + name + ' required by: ' + referrerName); } else { throw new Error('Could not find module ' + name); } } - function internalRequire(name, referrerName) { + function internalRequire(_name, referrerName) { + var name = _name; + var mod = registry[name]; + + if (!mod) { + name = name + '/index'; + mod = registry[name]; + } + var exports = seen[name]; if (exports !== undefined) { return exports; } exports = seen[name] = {}; - if (!registry[name]) { - missingModule(name, referrerName); + if (!mod) { + missingModule(_name, referrerName); } - var mod = registry[name]; var deps = mod.deps; var callback = mod.callback; var length = deps.length; var reified = new Array(length);; @@ -195,23 +208,12 @@ } } }; }); enifed('backburner/platform', ['exports'], function (exports) { - // In IE 6-8, try/finally doesn't work without a catch. - // Unfortunately, this is impossible to test for since wrapping it in a parent try/catch doesn't trigger the bug. - // This tests for another broken try/catch behavior that only exhibits in the same versions of IE. 'use strict'; - var needsIETryCatchFix = (function (e, x) { - try { - x(); - } catch (e) {} // jshint ignore:line - return !!e; - })(); - - exports.needsIETryCatchFix = needsIETryCatchFix; var platform; /* global self */ if (typeof self === 'object') { platform = self; @@ -535,13 +537,10 @@ this._boundRunExpiredTimers = function () { _this._runExpiredTimers(); }; } - // ms of delay before we conclude a timeout was lost - var TIMEOUT_STALLED_THRESHOLD = 1000; - Backburner.prototype = { begin: function () { var options = this.options; var onBegin = options && options.onBegin; var previousInstance = this.currentInstance; @@ -899,12 +898,10 @@ this._timers.push(executeAt, fn); this._installTimerTimeout(); return fn; } - this._reinstallStalledTimerTimeout(); - // find position to insert var i = _backburnerBinarySearch.default(executeAt, this._timers); this._timers.splice(i, 0, executeAt, fn); @@ -1097,25 +1094,10 @@ } timers.splice(0, i); this._installTimerTimeout(); }, - _reinstallStalledTimerTimeout: function () { - if (!this._timerTimeoutId) { - return; - } - // if we have a timer we should always have a this._timerTimeoutId - var minExpiresAt = this._timers[0]; - var delay = _backburnerUtils.now() - minExpiresAt; - // threshold of a second before we assume that the currently - // installed timeout will not run, so we don't constantly reinstall - // timeouts that are delayed but good still - if (delay < TIMEOUT_STALLED_THRESHOLD) { - return; - } - }, - _reinstallTimerTimeout: function () { this._clearTimerTimeout(); this._installTimerTimeout(); }, @@ -1140,18 +1122,10 @@ Backburner.prototype.schedule = Backburner.prototype.defer; Backburner.prototype.scheduleOnce = Backburner.prototype.deferOnce; Backburner.prototype.later = Backburner.prototype.setTimeout; - if (_backburnerPlatform.needsIETryCatchFix) { - var originalRun = Backburner.prototype.run; - Backburner.prototype.run = _backburnerUtils.wrapInTryCatch(originalRun); - - var originalEnd = Backburner.prototype.end; - Backburner.prototype.end = _backburnerUtils.wrapInTryCatch(originalEnd); - } - function getOnError(options) { return options.onError || options.onErrorTarget && options.onErrorTarget[options.onErrorMethod]; } function createAutorun(backburner) { @@ -1281,11 +1255,12 @@ twitter === twitter2; //=> false ``` @private @method lookup @param {String} fullName - @param {Object} options + @param {Object} [options] + @param {String} [options.source] The fullname of the request source (used for local lookup) @return {any} */ lookup: function (fullName, options) { _emberMetalDebug.assert('fullName must be a proper full name', this.registry.validateFullName(fullName)); return lookup(this, this.registry.normalize(fullName), options); @@ -1294,15 +1269,17 @@ /** Given a fullName return the corresponding factory. @private @method lookupFactory @param {String} fullName + @param {Object} [options] + @param {String} [options.source] The fullname of the request source (used for local lookup) @return {any} */ - lookupFactory: function (fullName) { + lookupFactory: function (fullName, options) { _emberMetalDebug.assert('fullName must be a proper full name', this.registry.validateFullName(fullName)); - return factoryFor(this, this.registry.normalize(fullName)); + return factoryFor(this, this.registry.normalize(fullName), options); }, /** A depth first traversal, destroying the container, its descendant containers and all their managed objects. @@ -1349,14 +1326,15 @@ function isSingleton(container, fullName) { return container.registry.getOption(fullName, 'singleton') !== false; } - function lookup(container, fullName, options) { - options = options || {}; + function lookup(container, _fullName, _options) { + var options = _options || {}; + var fullName = _fullName; - if (container.cache[fullName] && options.singleton !== false) { + if (container.cache[fullName] !== undefined && options.singleton !== false) { return container.cache[fullName]; } var value = instantiate(container, fullName); @@ -1405,16 +1383,19 @@ } return hash; } - function factoryFor(container, fullName) { + function factoryFor(container, _fullName, _options) { + var options = _options || {}; + var registry = container.registry; + var fullName = _fullName; + var cache = container.factoryCache; if (cache[fullName]) { return cache[fullName]; } - var registry = container.registry; var factory = registry.resolve(fullName); if (factory === undefined) { return; } @@ -1594,10 +1575,40 @@ } } exports.default = Container; }); + +// if expandLocalLookup returns falsey, we do not support local lookup + +// if expandLocalLookup returns falsey, we do not support local lookup +enifed('container/index', ['exports', 'ember-metal/core', 'container/registry', 'container/container', 'container/owner'], function (exports, _emberMetalCore, _containerRegistry, _containerContainer, _containerOwner) { + 'use strict'; + + /* + Public api for the container is still in flux. + The public api, specified on the application namespace should be considered the stable api. + // @module container + @private + */ + + /* + Flag to enable/disable model factory injections (disabled by default) + If model factory injections are enabled, models should not be + accessed globally (only through `container.lookupFactory('model:modelName'))`); + */ + _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = false; + + if (_emberMetalCore.default.ENV && typeof _emberMetalCore.default.ENV.MODEL_FACTORY_INJECTIONS !== 'undefined') { + _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = !!_emberMetalCore.default.ENV.MODEL_FACTORY_INJECTIONS; + } + + exports.Registry = _containerRegistry.default; + exports.Container = _containerContainer.default; + exports.getOwner = _containerOwner.getOwner; + exports.setOwner = _containerOwner.setOwner; +}); enifed('container/owner', ['exports', 'ember-metal/symbol'], function (exports, _emberMetalSymbol) { /** @module ember @submodule ember-runtime */ @@ -1666,11 +1677,11 @@ function setOwner(object, owner) { object[OWNER] = owner; } }); -enifed('container/registry', ['exports', 'ember-metal/debug', 'ember-metal/dictionary', 'ember-metal/assign', 'container/container'], function (exports, _emberMetalDebug, _emberMetalDictionary, _emberMetalAssign, _containerContainer) { +enifed('container/registry', ['exports', 'ember-metal/features', 'ember-metal/debug', 'ember-metal/dictionary', 'ember-metal/empty_object', 'ember-metal/assign', 'container/container'], function (exports, _emberMetalFeatures, _emberMetalDebug, _emberMetalDictionary, _emberMetalEmpty_object, _emberMetalAssign, _containerContainer) { 'use strict'; var VALID_FULL_NAME_REGEXP = /^[^:]+.+:[^:]+$/; /** @@ -1702,10 +1713,11 @@ this._typeInjections = _emberMetalDictionary.default(null); this._injections = _emberMetalDictionary.default(null); this._factoryTypeInjections = _emberMetalDictionary.default(null); this._factoryInjections = _emberMetalDictionary.default(null); + this._localLookupCache = new _emberMetalEmpty_object.default(); this._normalizeCache = _emberMetalDictionary.default(null); this._resolveCache = _emberMetalDictionary.default(null); this._failCache = _emberMetalDictionary.default(null); this._options = _emberMetalDictionary.default(null); @@ -1852,10 +1864,12 @@ unregister: function (fullName) { _emberMetalDebug.assert('fullName must be a proper full name', this.validateFullName(fullName)); var normalizedName = this.normalize(fullName); + this._localLookupCache = new _emberMetalEmpty_object.default(); + delete this.registrations[normalizedName]; delete this._resolveCache[normalizedName]; delete this._failCache[normalizedName]; delete this._options[normalizedName]; }, @@ -1882,17 +1896,21 @@ registry.resolve('api:twitter') // => Twitter ``` @private @method resolve @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) @return {Function} fullName's factory */ - resolve: function (fullName) { + resolve: function (fullName, options) { _emberMetalDebug.assert('fullName must be a proper full name', this.validateFullName(fullName)); - var factory = resolve(this, this.normalize(fullName)); + var factory = resolve(this, this.normalize(fullName), options); if (factory === undefined && this.fallback) { - factory = this.fallback.resolve(fullName); + var _fallback; + + factory = (_fallback = this.fallback).resolve.apply(_fallback, arguments); } return factory; }, /** @@ -1965,15 +1983,20 @@ Given a fullName check if the container is aware of its factory or singleton instance. @private @method has @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) @return {Boolean} */ - has: function (fullName) { + has: function (fullName, options) { _emberMetalDebug.assert('fullName must be a proper full name', this.validateFullName(fullName)); - return has(this, this.normalize(fullName)); + + var source = undefined; + + return has(this, this.normalize(fullName), source); }, /** Allow registering options for all factories of a type. ```javascript @@ -2011,12 +2034,12 @@ @private @method options @param {String} fullName @param {Object} options */ - options: function (fullName, options) { - options = options || {}; + options: function (fullName, _options) { + var options = _options || {}; var normalizedName = this.normalize(fullName); this._options[normalizedName] = options; }, getOptions: function (fullName) { @@ -2334,13 +2357,33 @@ registry.resolver = { resolve: registry.resolver }; } - function resolve(registry, normalizedName) { + function expandLocalLookup(registry, normalizedName, normalizedSource) { + var cache = registry._localLookupCache; + var normalizedNameCache = cache[normalizedName]; + + if (!normalizedNameCache) { + normalizedNameCache = cache[normalizedName] = new _emberMetalEmpty_object.default(); + } + + var cached = normalizedNameCache[normalizedSource]; + + if (cached !== undefined) { + return cached; + } + + var expanded = registry.resolver.expandLocalLookup(normalizedName, normalizedSource); + + return normalizedNameCache[normalizedSource] = expanded; + } + + function resolve(registry, normalizedName, options) { + var cached = registry._resolveCache[normalizedName]; - if (cached) { + if (cached !== undefined) { return cached; } if (registry._failCache[normalizedName]) { return; } @@ -2349,53 +2392,50 @@ if (registry.resolver) { resolved = registry.resolver.resolve(normalizedName); } - resolved = resolved || registry.registrations[normalizedName]; + if (resolved === undefined) { + resolved = registry.registrations[normalizedName]; + } - if (resolved) { - registry._resolveCache[normalizedName] = resolved; - } else { + if (resolved === undefined) { registry._failCache[normalizedName] = true; + } else { + registry._resolveCache[normalizedName] = resolved; } return resolved; } - function has(registry, fullName) { - return registry.resolve(fullName) !== undefined; + function has(registry, fullName, source) { + return registry.resolve(fullName, { source: source }) !== undefined; } exports.default = Registry; }); -enifed('container', ['exports', 'ember-metal/core', 'container/registry', 'container/container', 'container/owner'], function (exports, _emberMetalCore, _containerRegistry, _containerContainer, _containerOwner) { - 'use strict'; - /* - Public api for the container is still in flux. - The public api, specified on the application namespace should be considered the stable api. - // @module container - @private - */ +/** + Given a fullName and a source fullName returns the fully resolved + fullName. Used to allow for local lookup. + ```javascript + var registry = new Registry(); + // the twitter factory is added to the module system + registry.expandLocalLookup('component:post-title', { source: 'template:post' }) // => component:post/post-title + ``` + @private + @method expandLocalLookup + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) + @return {String} fullName +*/ - /* - Flag to enable/disable model factory injections (disabled by default) - If model factory injections are enabled, models should not be - accessed globally (only through `container.lookupFactory('model:modelName'))`); - */ - _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = false; +// when `source` is provided expand normalizedName +// and source into the full normalizedName - if (_emberMetalCore.default.ENV && typeof _emberMetalCore.default.ENV.MODEL_FACTORY_INJECTIONS !== 'undefined') { - _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = !!_emberMetalCore.default.ENV.MODEL_FACTORY_INJECTIONS; - } - - exports.Registry = _containerRegistry.default; - exports.Container = _containerContainer.default; - exports.getOwner = _containerOwner.getOwner; - exports.setOwner = _containerOwner.setOwner; -}); +// if expandLocalLookup returns falsey, we do not support local lookup enifed('dag-map/platform', ['exports'], function (exports) { 'use strict'; var platform; @@ -3634,13 +3674,51 @@ return protocol === null ? ':' : protocol; } exports.default = DOMHelper; }); -enifed('ember-application/system/application-instance', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/object', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/mixins/container_proxy', 'ember-htmlbars/system/dom-helper', 'container/registry', 'ember-runtime/mixins/registry_proxy', 'ember-metal-views/renderer', 'ember-metal/assign', 'ember-metal/environment', 'ember-runtime/ext/rsvp', 'ember-views/system/jquery'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberRuntimeSystemObject, _emberMetalRun_loop, _emberMetalComputed, _emberRuntimeMixinsContainer_proxy, _emberHtmlbarsSystemDomHelper, _containerRegistry, _emberRuntimeMixinsRegistry_proxy, _emberMetalViewsRenderer, _emberMetalAssign, _emberMetalEnvironment, _emberRuntimeExtRsvp, _emberViewsSystemJquery) { +enifed('ember/index', ['exports', 'ember-metal', 'ember-runtime', 'ember-views', 'ember-routing', 'ember-application', 'ember-extension-support', 'ember-htmlbars', 'ember-routing-htmlbars', 'ember-routing-views', 'require', 'ember-runtime/system/lazy_load'], function (exports, _emberMetal, _emberRuntime, _emberViews, _emberRouting, _emberApplication, _emberExtensionSupport, _emberHtmlbars, _emberRoutingHtmlbars, _emberRoutingViews, _require, _emberRuntimeSystemLazy_load) { + // require the main entry points for each of these packages + // this is so that the global exports occur properly + 'use strict'; + + if (_require.has('ember-template-compiler')) { + _require.default('ember-template-compiler'); + } + + // do this to ensure that Ember.Test is defined properly on the global + // if it is present. + if (_require.has('ember-testing')) { + _require.default('ember-testing'); + } + + _emberRuntimeSystemLazy_load.runLoadHooks('Ember'); + /** @module ember + */ +}); +enifed('ember-application/index', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-runtime/system/lazy_load', 'ember-application/system/resolver', 'ember-application/system/application', 'ember-application/system/application-instance', 'ember-application/system/engine', 'ember-application/system/engine-instance'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberRuntimeSystemLazy_load, _emberApplicationSystemResolver, _emberApplicationSystemApplication, _emberApplicationSystemApplicationInstance, _emberApplicationSystemEngine, _emberApplicationSystemEngineInstance) { + 'use strict'; + + _emberMetalCore.default.Application = _emberApplicationSystemApplication.default; + _emberMetalCore.default.Resolver = _emberApplicationSystemResolver.Resolver; + _emberMetalCore.default.DefaultResolver = _emberApplicationSystemResolver.default; + + _emberRuntimeSystemLazy_load.runLoadHooks('Ember.Application', _emberApplicationSystemApplication.default); +}); + +/** +@module ember +@submodule ember-application +*/ + +// Expose `EngineInstance` and `ApplicationInstance` for easy overriding. +// Reanalyze whether to continue exposing these after feature flag is removed. +enifed('ember-application/system/application-instance', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-htmlbars/system/dom-helper', 'ember-runtime/mixins/registry_proxy', 'ember-metal-views/renderer', 'ember-metal/assign', 'ember-metal/environment', 'ember-runtime/ext/rsvp', 'ember-views/system/jquery', 'ember-application/system/engine-instance'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalComputed, _emberHtmlbarsSystemDomHelper, _emberRuntimeMixinsRegistry_proxy, _emberMetalViewsRenderer, _emberMetalAssign, _emberMetalEnvironment, _emberRuntimeExtRsvp, _emberViewsSystemJquery, _emberApplicationSystemEngineInstance) { + /** + @module ember @submodule ember-application */ 'use strict'; @@ -3666,16 +3744,14 @@ creating the container that contains all application state, and disposing of it once the particular test run or FastBoot request has finished. @public @class Ember.ApplicationInstance - @extends Ember.Object - @uses RegistryProxyMixin - @uses ContainerProxyMixin + @extends Ember.EngineInstance */ - var ApplicationInstance = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsRegistry_proxy.default, _emberRuntimeMixinsContainer_proxy.default, { + var ApplicationInstance = _emberApplicationSystemEngineInstance.default.extend({ /** The `Application` for which this is an instance. @property {Ember.Application} application @private */ @@ -3702,22 +3778,12 @@ rootElement: null, init: function () { this._super.apply(this, arguments); - var application = _emberMetalProperty_get.get(this, 'application'); + var application = this.application; - // Create a per-instance registry that will use the application's registry - // as a fallback for resolving registrations. - var applicationRegistry = _emberMetalProperty_get.get(application, '__registry__'); - var registry = this.__registry__ = new _containerRegistry.default({ - fallback: applicationRegistry - }); - - // Create a per-instance container from the instance's registry - this.__container__ = registry.container({ owner: this }); - // Register this instance in the per-instance registry. // // Why do we need to register the instance in the first place? // Because we need a good way for the root route (a.k.a ApplicationRoute) // to notify us when it has created the root-most view. That view is then @@ -3830,11 +3896,11 @@ To start the app at a specific URL, call `handleURL` instead. @private */ startRouting: function () { var router = _emberMetalProperty_get.get(this, 'router'); - router.startRouting(isResolverModuleBased(this)); + router.startRouting(); this._didSetupRouter = true; }, /** @private @@ -3848,11 +3914,11 @@ return; } this._didSetupRouter = true; var router = _emberMetalProperty_get.get(this, 'router'); - router.setupRouter(isResolverModuleBased(this)); + router.setupRouter(); }, /** Directs the router to route to a particular URL. This is useful in tests, for example, to tell the app to start at a particular URL. @@ -3876,31 +3942,10 @@ var customEvents = _emberMetalAssign.default({}, applicationCustomEvents, instanceCustomEvents); dispatcher.setup(customEvents, this.rootElement); return dispatcher; - }, - - /** - @private - */ - willDestroy: function () { - this._super.apply(this, arguments); - _emberMetalRun_loop.default(this.__container__, 'destroy'); - }, - - /** - Unregister a factory. - Overrides `RegistryProxy#unregister` in order to clear any cached instances - of the unregistered factory. - @public - @method unregister - @param {String} fullName - */ - unregister: function (fullName) { - this.__container__.reset(fullName); - this._super.apply(this, arguments); } }); ApplicationInstance.reopen({ /** @@ -4129,14 +4174,10 @@ env.hasDOM = this.isBrowser; env.options = this; return env; }; - function isResolverModuleBased(applicationInstance) { - return !!applicationInstance.application.__registry__.resolver.moduleBasedResolver; - } - Object.defineProperty(ApplicationInstance.prototype, 'container', { configurable: true, enumerable: false, get: function () { var instance = this; @@ -4161,27 +4202,17 @@ } }); exports.default = ApplicationInstance; }); -enifed('ember-application/system/application', ['exports', 'dag-map', 'container/registry', 'ember-metal', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/empty_object', 'ember-runtime/system/lazy_load', 'ember-runtime/system/namespace', 'ember-application/system/resolver', 'ember-metal/run_loop', 'ember-metal/utils', 'ember-runtime/controllers/controller', 'ember-metal-views/renderer', 'ember-htmlbars/system/dom-helper', 'ember-views/views/select', 'ember-routing-views/views/outlet', 'ember-views/views/view', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery', 'ember-routing/system/route', 'ember-routing/system/router', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/location/none_location', 'ember-routing/system/cache', 'ember-application/system/application-instance', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/checkbox', 'ember-views/views/legacy_each_view', 'ember-routing-views/components/link-to', 'ember-routing/services/routing', 'ember-extension-support/container_debug_adapter', 'ember-runtime/mixins/registry_proxy', 'ember-metal/environment', 'ember-runtime/ext/rsvp'], function (exports, _dagMap, _containerRegistry, _emberMetal, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalEmpty_object, _emberRuntimeSystemLazy_load, _emberRuntimeSystemNamespace, _emberApplicationSystemResolver, _emberMetalRun_loop, _emberMetalUtils, _emberRuntimeControllersController, _emberMetalViewsRenderer, _emberHtmlbarsSystemDomHelper, _emberViewsViewsSelect, _emberRoutingViewsViewsOutlet, _emberViewsViewsView, _emberViewsSystemEvent_dispatcher, _emberViewsSystemJquery, _emberRoutingSystemRoute, _emberRoutingSystemRouter, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingLocationNone_location, _emberRoutingSystemCache, _emberApplicationSystemApplicationInstance, _emberViewsViewsText_field, _emberViewsViewsText_area, _emberViewsViewsCheckbox, _emberViewsViewsLegacy_each_view, _emberRoutingViewsComponentsLinkTo, _emberRoutingServicesRouting, _emberExtensionSupportContainer_debug_adapter, _emberRuntimeMixinsRegistry_proxy, _emberMetalEnvironment, _emberRuntimeExtRsvp) { +enifed('ember-application/system/application', ['exports', 'ember-metal', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-runtime/system/lazy_load', 'ember-metal/run_loop', 'ember-runtime/controllers/controller', 'ember-metal-views/renderer', 'ember-htmlbars/system/dom-helper', 'ember-views/views/select', 'ember-routing-views/views/outlet', 'ember-views/views/view', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery', 'ember-routing/system/route', 'ember-routing/system/router', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/location/none_location', 'ember-routing/system/cache', 'ember-application/system/application-instance', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/checkbox', 'ember-views/views/legacy_each_view', 'ember-routing-views/components/link-to', 'ember-routing/services/routing', 'ember-extension-support/container_debug_adapter', 'ember-runtime/mixins/registry_proxy', 'ember-metal/environment', 'ember-runtime/ext/rsvp', 'ember-application/system/engine'], function (exports, _emberMetal, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberRuntimeSystemLazy_load, _emberMetalRun_loop, _emberRuntimeControllersController, _emberMetalViewsRenderer, _emberHtmlbarsSystemDomHelper, _emberViewsViewsSelect, _emberRoutingViewsViewsOutlet, _emberViewsViewsView, _emberViewsSystemEvent_dispatcher, _emberViewsSystemJquery, _emberRoutingSystemRoute, _emberRoutingSystemRouter, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingLocationNone_location, _emberRoutingSystemCache, _emberApplicationSystemApplicationInstance, _emberViewsViewsText_field, _emberViewsViewsText_area, _emberViewsViewsCheckbox, _emberViewsViewsLegacy_each_view, _emberRoutingViewsComponentsLinkTo, _emberRoutingServicesRouting, _emberExtensionSupportContainer_debug_adapter, _emberRuntimeMixinsRegistry_proxy, _emberMetalEnvironment, _emberRuntimeExtRsvp, _emberApplicationSystemEngine) { /** @module ember @submodule ember-application */ 'use strict'; - function props(obj) { - var properties = []; - - for (var key in obj) { - properties.push(key); - } - - return properties; - } - var librariesRegistered = false; /** An instance of `Ember.Application` is the starting point for every Ember application. It helps to instantiate, initialize and coordinate the many @@ -4332,16 +4363,16 @@ `ready()` method on your app that will be invoked immediately before routing begins. @class Application @namespace Ember - @extends Ember.Namespace + @extends Ember.Engine @uses RegistryProxyMixin @public */ - var Application = _emberRuntimeSystemNamespace.default.extend(_emberRuntimeMixinsRegistry_proxy.default, { + var Application = _emberApplicationSystemEngine.default.extend({ _suppressDeferredDeprecation: true, /** The root DOM element of the Application. This can be specified as an element or a @@ -4463,12 +4494,10 @@ if (!this.$) { this.$ = _emberViewsSystemJquery.default; } - this.buildRegistry(); - registerLibraries(); logLibraryVersions(); // Start off the number of deferrals at 1. This will be decremented by // the Application's own `boot` method. @@ -4485,30 +4514,19 @@ this.waitForDOMReady(); } }, /** - Build and configure the registry for the current application. - @private - @method buildRegistry - @return {Ember.Registry} the configured registry - */ - buildRegistry: function () { - var registry = this.__registry__ = Application.buildRegistry(this); - - return registry; - }, - - /** Create an ApplicationInstance for this application. @private @method buildInstance @return {Ember.ApplicationInstance} the application instance */ buildInstance: function () { var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + options.base = this; options.application = this; return _emberApplicationSystemApplicationInstance.default.create(options); }, /** @@ -4792,68 +4810,10 @@ _emberMetalRun_loop.default.join(this, handleReset); }, /** @private - @method instanceInitializer - */ - instanceInitializer: function (options) { - this.constructor.instanceInitializer(options); - }, - - /** - @private - @method runInitializers - */ - runInitializers: function () { - var App = this; - this._runInitializer('initializers', function (name, initializer) { - _emberMetalDebug.assert('No application initializer named \'' + name + '\'', !!initializer); - if (initializer.initialize.length === 2) { - _emberMetalDebug.deprecate('The `initialize` method for Application initializer \'' + name + '\' should take only one argument - `App`, an instance of an `Application`.', false, { - id: 'ember-application.app-initializer-initialize-arguments', - until: '3.0.0', - url: 'http://emberjs.com/deprecations/v2.x/#toc_initializer-arity' - }); - - initializer.initialize(App.__registry__, App); - } else { - initializer.initialize(App); - } - }); - }, - - /** - @private - @since 1.12.0 - @method runInstanceInitializers - */ - runInstanceInitializers: function (instance) { - this._runInitializer('instanceInitializers', function (name, initializer) { - _emberMetalDebug.assert('No instance initializer named \'' + name + '\'', !!initializer); - initializer.initialize(instance); - }); - }, - - _runInitializer: function (bucketName, cb) { - var initializersByName = _emberMetalProperty_get.get(this.constructor, bucketName); - var initializers = props(initializersByName); - var graph = new _dagMap.default(); - var initializer; - - for (var i = 0; i < initializers.length; i++) { - initializer = initializersByName[initializers[i]]; - graph.addEdges(initializer.name, initializer, initializer.before, initializer.after); - } - - graph.topsort(function (vertex) { - cb(vertex.name, vertex.value); - }); - }, - - /** - @private @method didBecomeReady */ didBecomeReady: function () { try { // TODO: Is this still needed for _globalsMode = false? @@ -4909,25 +4869,10 @@ */ ready: function () { return this; }, - /** - Set this to provide an alternate class to `Ember.DefaultResolver` - @deprecated Use 'Resolver' instead - @property resolver - @public - */ - resolver: null, - - /** - Set this to provide an alternate class to `Ember.DefaultResolver` - @property resolver - @public - */ - Resolver: null, - // This method must be moved to the application instance object willDestroy: function () { this._super.apply(this, arguments); _emberMetal.default.BOOTED = false; this._booted = false; @@ -4939,14 +4884,10 @@ } if (this._globalsMode && this.__deprecatedInstance__) { this.__deprecatedInstance__.destroy(); } - }, - - initializer: function (options) { - this.constructor.initializer(options); } }); Object.defineProperty(Application.prototype, 'registry', { configurable: true, @@ -4954,67 +4895,10 @@ get: function () { return _emberRuntimeMixinsRegistry_proxy.buildFakeRegistryWithDeprecations(this, 'Application'); } }); - Application.reopenClass({ - /** - Instance initializers run after all initializers have run. Because - instance initializers run after the app is fully set up. We have access - to the store, container, and other items. However, these initializers run - after code has loaded and are not allowed to defer readiness. - Instance initializer receives an object which has the following attributes: - `name`, `before`, `after`, `initialize`. The only required attribute is - `initialize`, all others are optional. - * `name` allows you to specify under which name the instanceInitializer is - registered. This must be a unique name, as trying to register two - instanceInitializer with the same name will result in an error. - ```javascript - Ember.Application.instanceInitializer({ - name: 'namedinstanceInitializer', - initialize: function(application) { - Ember.debug('Running namedInitializer!'); - } - }); - ``` - * `before` and `after` are used to ensure that this initializer is ran prior - or after the one identified by the value. This value can be a single string - or an array of strings, referencing the `name` of other initializers. - * See Ember.Application.initializer for discussion on the usage of before - and after. - Example instanceInitializer to preload data into the store. - ```javascript - Ember.Application.initializer({ - name: 'preload-data', - initialize: function(application) { - var userConfig, userConfigEncoded, store; - // We have a HTML escaped JSON representation of the user's basic - // configuration generated server side and stored in the DOM of the main - // index.html file. This allows the app to have access to a set of data - // without making any additional remote calls. Good for basic data that is - // needed for immediate rendering of the page. Keep in mind, this data, - // like all local models and data can be manipulated by the user, so it - // should not be relied upon for security or authorization. - // - // Grab the encoded data from the meta tag - userConfigEncoded = Ember.$('head meta[name=app-user-config]').attr('content'); - // Unescape the text, then parse the resulting JSON into a real object - userConfig = JSON.parse(unescape(userConfigEncoded)); - // Lookup the store - store = application.lookup('service:store'); - // Push the encoded JSON into the store - store.pushPayload(userConfig); - } - }); - ``` - @method instanceInitializer - @param instanceInitializer - @public - */ - instanceInitializer: buildInitializerMethod('instanceInitializers', 'instance initializer') - }); - Application.reopen({ /** Boot a new instance of `Ember.ApplicationInstance` for the current application and navigate it to the given `url`. Returns a `Promise` that resolves with the instance when the initial routing and rendering is @@ -5176,10 +5060,350 @@ }); } }); Application.reopenClass({ + /** + This creates a registry with the default Ember naming conventions. + It also configures the registry: + * registered views are created every time they are looked up (they are + not singletons) + * registered templates are not factories; the registered value is + returned directly. + * the router receives the application as its `namespace` property + * all controllers receive the router as their `target` and `controllers` + properties + * all controllers receive the application as their `namespace` property + * the application view receives the application controller as its + `controller` property + * the application view receives the application template as its + `defaultTemplate` property + @private + @method buildRegistry + @static + @param {Ember.Application} namespace the application for which to + build the registry + @return {Ember.Registry} the built registry + @public + */ + buildRegistry: function (namespace) { + var registry = this._super.apply(this, arguments); + + registry.optionsForType('component', { singleton: false }); + registry.optionsForType('view', { singleton: false }); + registry.optionsForType('template', { instantiate: false }); + + registry.register('application:main', namespace, { instantiate: false }); + + registry.register('controller:basic', _emberRuntimeControllersController.default, { instantiate: false }); + + registry.register('renderer:-dom', { create: function () { + return new _emberMetalViewsRenderer.default(new _emberHtmlbarsSystemDomHelper.default()); + } }); + + registry.injection('view', 'renderer', 'renderer:-dom'); + if (_emberMetal.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + registry.register('view:select', _emberViewsViewsSelect.default); + } + registry.register('view:-outlet', _emberRoutingViewsViewsOutlet.OutletView); + + registry.register('-view-registry:main', { create: function () { + return {}; + } }); + + registry.injection('view', '_viewRegistry', '-view-registry:main'); + + registry.register('view:toplevel', _emberViewsViewsView.default.extend()); + + registry.register('route:basic', _emberRoutingSystemRoute.default, { instantiate: false }); + registry.register('event_dispatcher:main', _emberViewsSystemEvent_dispatcher.default); + + registry.injection('router:main', 'namespace', 'application:main'); + registry.injection('view:-outlet', 'namespace', 'application:main'); + + registry.register('location:auto', _emberRoutingLocationAuto_location.default); + registry.register('location:hash', _emberRoutingLocationHash_location.default); + registry.register('location:history', _emberRoutingLocationHistory_location.default); + registry.register('location:none', _emberRoutingLocationNone_location.default); + + registry.injection('controller', 'target', 'router:main'); + registry.injection('controller', 'namespace', 'application:main'); + + registry.register('-bucket-cache:main', _emberRoutingSystemCache.default); + registry.injection('router', '_bucketCache', '-bucket-cache:main'); + registry.injection('route', '_bucketCache', '-bucket-cache:main'); + registry.injection('controller', '_bucketCache', '-bucket-cache:main'); + + registry.injection('route', 'router', 'router:main'); + + registry.register('component:-text-field', _emberViewsViewsText_field.default); + registry.register('component:-text-area', _emberViewsViewsText_area.default); + registry.register('component:-checkbox', _emberViewsViewsCheckbox.default); + registry.register('view:-legacy-each', _emberViewsViewsLegacy_each_view.default); + registry.register('component:link-to', _emberRoutingViewsComponentsLinkTo.default); + + // Register the routing service... + registry.register('service:-routing', _emberRoutingServicesRouting.default); + // Then inject the app router into it + registry.injection('service:-routing', 'router', 'router:main'); + + // DEBUGGING + registry.register('resolver-for-debugging:main', registry.resolver, { instantiate: false }); + registry.injection('container-debug-adapter:main', 'resolver', 'resolver-for-debugging:main'); + registry.injection('data-adapter:main', 'containerDebugAdapter', 'container-debug-adapter:main'); + // Custom resolver authors may want to register their own ContainerDebugAdapter with this key + + registry.register('container-debug-adapter:main', _emberExtensionSupportContainer_debug_adapter.default); + + return registry; + } + }); + + function registerLibraries() { + if (!librariesRegistered) { + librariesRegistered = true; + + if (_emberMetalEnvironment.default.hasDOM) { + _emberMetal.default.libraries.registerCoreLibrary('jQuery', _emberViewsSystemJquery.default().jquery); + } + } + } + + function logLibraryVersions() { + if (_emberMetal.default.LOG_VERSION) { + // we only need to see this once per Application#init + _emberMetal.default.LOG_VERSION = false; + var libs = _emberMetal.default.libraries._registry; + + var nameLengths = libs.map(function (item) { + return _emberMetalProperty_get.get(item, 'name.length'); + }); + + var maxNameLength = Math.max.apply(this, nameLengths); + + _emberMetalDebug.debug('-------------------------------'); + for (var i = 0, l = libs.length; i < l; i++) { + var lib = libs[i]; + var spaces = new Array(maxNameLength - lib.name.length + 1).join(' '); + _emberMetalDebug.debug([lib.name, spaces, ' : ', lib.version].join('')); + } + _emberMetalDebug.debug('-------------------------------'); + } + } + + exports.default = Application; +}); +// Ember.libraries, LOG_VERSION, Namespace, BOOTED + +// Force-assign these flags to their default values when the feature is +// disabled, this ensures we can rely on their values in other paths. +enifed('ember-application/system/engine-instance', ['exports', 'ember-runtime/system/object', 'container/registry', 'ember-runtime/mixins/container_proxy', 'ember-runtime/mixins/registry_proxy', 'ember-metal/run_loop'], function (exports, _emberRuntimeSystemObject, _containerRegistry, _emberRuntimeMixinsContainer_proxy, _emberRuntimeMixinsRegistry_proxy, _emberMetalRun_loop) { + /** + @module ember + @submodule ember-application + */ + + 'use strict'; + + /** + The `EngineInstance` encapsulates all of the stateful aspects of a + running `Engine`. + + @public + @class Ember.EngineInstance + @extends Ember.Object + @uses RegistryProxyMixin + @uses ContainerProxyMixin + */ + + var EngineInstance = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsRegistry_proxy.default, _emberRuntimeMixinsContainer_proxy.default, { + /** + The base `Engine` for which this is an instance. + @property {Ember.Engine} engine + @private + */ + base: null, + + init: function () { + this._super.apply(this, arguments); + + var base = this.base; + + if (!base) { + base = this.application; + this.base = base; + } + + // Create a per-instance registry that will use the application's registry + // as a fallback for resolving registrations. + var registry = this.__registry__ = new _containerRegistry.default({ + fallback: base.__registry__ + }); + + // Create a per-instance container from the instance's registry + this.__container__ = registry.container({ owner: this }); + }, + + /** + Unregister a factory. + Overrides `RegistryProxy#unregister` in order to clear any cached instances + of the unregistered factory. + @public + @method unregister + @param {String} fullName + */ + unregister: function (fullName) { + this.__container__.reset(fullName); + this._super.apply(this, arguments); + }, + + /** + @private + */ + willDestroy: function () { + this._super.apply(this, arguments); + _emberMetalRun_loop.default(this.__container__, 'destroy'); + } + }); + + exports.default = EngineInstance; +}); +enifed('ember-application/system/engine', ['exports', 'ember-runtime/system/namespace', 'container/registry', 'ember-runtime/mixins/registry_proxy', 'dag-map', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/debug', 'ember-metal/utils', 'ember-metal/empty_object', 'ember-application/system/resolver', 'ember-application/system/engine-instance'], function (exports, _emberRuntimeSystemNamespace, _containerRegistry, _emberRuntimeMixinsRegistry_proxy, _dagMap, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalDebug, _emberMetalUtils, _emberMetalEmpty_object, _emberApplicationSystemResolver, _emberApplicationSystemEngineInstance) { + /** + @module ember + @submodule ember-application + */ + 'use strict'; + + function props(obj) { + var properties = []; + + for (var key in obj) { + properties.push(key); + } + + return properties; + } + + /** + The `Engine` class contains core functionality for both applications and + engines. + + Each engine manages a registry that's used for dependency injection and + exposed through `RegistryProxy`. + + Engines also manage initializers and instance initializers. + + Engines can spawn `EngineInstance` instances via `buildInstance()`. + + @class Engine + @namespace Ember + @extends Ember.Namespace + @uses RegistryProxy + @public + */ + var Engine = _emberRuntimeSystemNamespace.default.extend(_emberRuntimeMixinsRegistry_proxy.default, { + init: function () { + this._super.apply(this, arguments); + + this.buildRegistry(); + }, + + /** + Create an EngineInstance for this application. + @private + @method buildInstance + @return {Ember.EngineInstance} the application instance + */ + buildInstance: function () { + var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + options.base = this; + return _emberApplicationSystemEngineInstance.default.create(options); + }, + + /** + Build and configure the registry for the current application. + @private + @method buildRegistry + @return {Ember.Registry} the configured registry + */ + buildRegistry: function () { + var registry = this.__registry__ = this.constructor.buildRegistry(this); + + return registry; + }, + + /** + @private + @method initializer + */ + initializer: function (options) { + this.constructor.initializer(options); + }, + + /** + @private + @method instanceInitializer + */ + instanceInitializer: function (options) { + this.constructor.instanceInitializer(options); + }, + + /** + @private + @method runInitializers + */ + runInitializers: function () { + var _this = this; + + this._runInitializer('initializers', function (name, initializer) { + _emberMetalDebug.assert('No application initializer named \'' + name + '\'', !!initializer); + if (initializer.initialize.length === 2) { + _emberMetalDebug.deprecate('The `initialize` method for Application initializer \'' + name + '\' should take only one argument - `App`, an instance of an `Application`.', false, { + id: 'ember-application.app-initializer-initialize-arguments', + until: '3.0.0', + url: 'http://emberjs.com/deprecations/v2.x/#toc_initializer-arity' + }); + + initializer.initialize(_this.__registry__, _this); + } else { + initializer.initialize(_this); + } + }); + }, + + /** + @private + @since 1.12.0 + @method runInstanceInitializers + */ + runInstanceInitializers: function (instance) { + this._runInitializer('instanceInitializers', function (name, initializer) { + _emberMetalDebug.assert('No instance initializer named \'' + name + '\'', !!initializer); + initializer.initialize(instance); + }); + }, + + _runInitializer: function (bucketName, cb) { + var initializersByName = _emberMetalProperty_get.get(this.constructor, bucketName); + var initializers = props(initializersByName); + var graph = new _dagMap.default(); + var initializer; + + for (var i = 0; i < initializers.length; i++) { + initializer = initializersByName[initializers[i]]; + graph.addEdges(initializer.name, initializer, initializer.before, initializer.after); + } + + graph.topsort(function (vertex) { + cb(vertex.name, vertex.value); + }); + } + }); + + Engine.reopenClass({ initializers: new _emberMetalEmpty_object.default(), instanceInitializers: new _emberMetalEmpty_object.default(), /** The goal of initializers should be to register dependencies and injections. @@ -5274,10 +5498,65 @@ */ initializer: buildInitializerMethod('initializers', 'initializer'), /** + Instance initializers run after all initializers have run. Because + instance initializers run after the app is fully set up. We have access + to the store, container, and other items. However, these initializers run + after code has loaded and are not allowed to defer readiness. + Instance initializer receives an object which has the following attributes: + `name`, `before`, `after`, `initialize`. The only required attribute is + `initialize`, all others are optional. + * `name` allows you to specify under which name the instanceInitializer is + registered. This must be a unique name, as trying to register two + instanceInitializer with the same name will result in an error. + ```javascript + Ember.Application.instanceInitializer({ + name: 'namedinstanceInitializer', + initialize: function(application) { + Ember.debug('Running namedInitializer!'); + } + }); + ``` + * `before` and `after` are used to ensure that this initializer is ran prior + or after the one identified by the value. This value can be a single string + or an array of strings, referencing the `name` of other initializers. + * See Ember.Application.initializer for discussion on the usage of before + and after. + Example instanceInitializer to preload data into the store. + ```javascript + Ember.Application.initializer({ + name: 'preload-data', + initialize: function(application) { + var userConfig, userConfigEncoded, store; + // We have a HTML escaped JSON representation of the user's basic + // configuration generated server side and stored in the DOM of the main + // index.html file. This allows the app to have access to a set of data + // without making any additional remote calls. Good for basic data that is + // needed for immediate rendering of the page. Keep in mind, this data, + // like all local models and data can be manipulated by the user, so it + // should not be relied upon for security or authorization. + // + // Grab the encoded data from the meta tag + userConfigEncoded = Ember.$('head meta[name=app-user-config]').attr('content'); + // Unescape the text, then parse the resulting JSON into a real object + userConfig = JSON.parse(unescape(userConfigEncoded)); + // Lookup the store + store = application.lookup('service:store'); + // Push the encoded JSON into the store + store.pushPayload(userConfig); + } + }); + ``` + @method instanceInitializer + @param instanceInitializer + @public + */ + instanceInitializer: buildInitializerMethod('instanceInitializers', 'instance initializer'), + + /** This creates a registry with the default Ember naming conventions. It also configures the registry: * registered views are created every time they are looked up (they are not singletons) * registered templates are not factories; the registered value is @@ -5303,78 +5582,27 @@ resolver: resolverFor(namespace) }); registry.set = _emberMetalProperty_set.set; - registry.optionsForType('component', { singleton: false }); - registry.optionsForType('view', { singleton: false }); - registry.optionsForType('template', { instantiate: false }); + return registry; + }, - registry.register('application:main', namespace, { instantiate: false }); + /** + Set this to provide an alternate class to `Ember.DefaultResolver` + @deprecated Use 'Resolver' instead + @property resolver + @public + */ + resolver: null, - registry.register('controller:basic', _emberRuntimeControllersController.default, { instantiate: false }); - - registry.register('renderer:-dom', { create: function () { - return new _emberMetalViewsRenderer.default(new _emberHtmlbarsSystemDomHelper.default()); - } }); - - registry.injection('view', 'renderer', 'renderer:-dom'); - if (_emberMetal.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - registry.register('view:select', _emberViewsViewsSelect.default); - } - registry.register('view:-outlet', _emberRoutingViewsViewsOutlet.OutletView); - - registry.register('-view-registry:main', { create: function () { - return {}; - } }); - - registry.injection('view', '_viewRegistry', '-view-registry:main'); - - registry.register('view:toplevel', _emberViewsViewsView.default.extend()); - - registry.register('route:basic', _emberRoutingSystemRoute.default, { instantiate: false }); - registry.register('event_dispatcher:main', _emberViewsSystemEvent_dispatcher.default); - - registry.injection('router:main', 'namespace', 'application:main'); - registry.injection('view:-outlet', 'namespace', 'application:main'); - - registry.register('location:auto', _emberRoutingLocationAuto_location.default); - registry.register('location:hash', _emberRoutingLocationHash_location.default); - registry.register('location:history', _emberRoutingLocationHistory_location.default); - registry.register('location:none', _emberRoutingLocationNone_location.default); - - registry.injection('controller', 'target', 'router:main'); - registry.injection('controller', 'namespace', 'application:main'); - - registry.register('-bucket-cache:main', _emberRoutingSystemCache.default); - registry.injection('router', '_bucketCache', '-bucket-cache:main'); - registry.injection('route', '_bucketCache', '-bucket-cache:main'); - registry.injection('controller', '_bucketCache', '-bucket-cache:main'); - - registry.injection('route', 'router', 'router:main'); - - registry.register('component:-text-field', _emberViewsViewsText_field.default); - registry.register('component:-text-area', _emberViewsViewsText_area.default); - registry.register('component:-checkbox', _emberViewsViewsCheckbox.default); - registry.register('view:-legacy-each', _emberViewsViewsLegacy_each_view.default); - registry.register('component:link-to', _emberRoutingViewsComponentsLinkTo.default); - - // Register the routing service... - registry.register('service:-routing', _emberRoutingServicesRouting.default); - // Then inject the app router into it - registry.injection('service:-routing', 'router', 'router:main'); - - // DEBUGGING - registry.register('resolver-for-debugging:main', registry.resolver, { instantiate: false }); - registry.injection('container-debug-adapter:main', 'resolver', 'resolver-for-debugging:main'); - registry.injection('data-adapter:main', 'containerDebugAdapter', 'container-debug-adapter:main'); - // Custom resolver authors may want to register their own ContainerDebugAdapter with this key - - registry.register('container-debug-adapter:main', _emberExtensionSupportContainer_debug_adapter.default); - - return registry; - } + /** + Set this to provide an alternate class to `Ember.DefaultResolver` + @property resolver + @public + */ + Resolver: null }); /** This function defines the default lookup rules for container lookups: @@ -5397,42 +5625,10 @@ return ResolverClass.create({ namespace: namespace }); } - function registerLibraries() { - if (!librariesRegistered) { - librariesRegistered = true; - - if (_emberMetalEnvironment.default.hasDOM) { - _emberMetal.default.libraries.registerCoreLibrary('jQuery', _emberViewsSystemJquery.default().jquery); - } - } - } - - function logLibraryVersions() { - if (_emberMetal.default.LOG_VERSION) { - // we only need to see this once per Application#init - _emberMetal.default.LOG_VERSION = false; - var libs = _emberMetal.default.libraries._registry; - - var nameLengths = libs.map(function (item) { - return _emberMetalProperty_get.get(item, 'name.length'); - }); - - var maxNameLength = Math.max.apply(this, nameLengths); - - _emberMetalDebug.debug('-------------------------------'); - for (var i = 0, l = libs.length; i < l; i++) { - var lib = libs[i]; - var spaces = new Array(maxNameLength - lib.name.length + 1).join(' '); - _emberMetalDebug.debug([lib.name, spaces, ' : ', lib.version].join('')); - } - _emberMetalDebug.debug('-------------------------------'); - } - } - function buildInitializerMethod(bucketName, humanName) { return function (initializer) { // If this is the first initializer being added to a subclass, we are going to reopen the class // to make sure we have a new `initializers` object, which extends from the parent class' using // prototypal inheritance. Without this, attempting to add initializers to the subclass would @@ -5449,16 +5645,12 @@ this[bucketName][initializer.name] = initializer; }; } - exports.default = Application; + exports.default = Engine; }); -// Ember.libraries, LOG_VERSION, Namespace, BOOTED - -// Force-assign these flags to their default values when the feature is -// disabled, this ensures we can rely on their values in other paths. enifed('ember-application/system/resolver', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/namespace', 'ember-htmlbars/helpers', 'ember-application/utils/validate-type', 'ember-metal/dictionary', 'ember-htmlbars/template_registry'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace, _emberHtmlbarsHelpers, _emberApplicationUtilsValidateType, _emberMetalDictionary, _emberHtmlbarsTemplate_registry) { /** @module ember @submodule ember-application */ @@ -5653,12 +5845,14 @@ var fullNameWithoutType = _fullName$split2[1]; var name = fullNameWithoutType; var namespace = _emberMetalProperty_get.get(this, 'namespace'); var root = namespace; + var lastSlashIndex = name.lastIndexOf('/'); + var dirname = lastSlashIndex !== -1 ? name.slice(0, lastSlashIndex) : null; - if (type !== 'template' && name.indexOf('/') !== -1) { + if (type !== 'template' && lastSlashIndex !== -1) { var parts = name.split('/'); name = parts[parts.length - 1]; var namespaceName = _emberRuntimeSystemString.capitalize(parts.slice(0, -1).join('.')); root = _emberRuntimeSystemNamespace.default.byName(namespaceName); @@ -5673,10 +5867,11 @@ return { fullName: fullName, type: type, fullNameWithoutType: fullNameWithoutType, + dirname: dirname, name: name, root: root, resolveMethodName: 'resolve' + resolveMethodName }; }, @@ -5932,24 +6127,10 @@ } else { _emberMetalDebug.assert('Expected ' + parsedName.fullName + ' to resolve to an ' + expectedType + ' but ' + ('instead it was ' + resolvedType + '.'), !!resolvedType[factoryFlag]); } } }); -enifed('ember-application', ['exports', 'ember-metal/core', 'ember-runtime/system/lazy_load', 'ember-application/system/resolver', 'ember-application/system/application'], function (exports, _emberMetalCore, _emberRuntimeSystemLazy_load, _emberApplicationSystemResolver, _emberApplicationSystemApplication) { - 'use strict'; - - _emberMetalCore.default.Application = _emberApplicationSystemApplication.default; - _emberMetalCore.default.Resolver = _emberApplicationSystemResolver.Resolver; - _emberMetalCore.default.DefaultResolver = _emberApplicationSystemResolver.default; - - _emberRuntimeSystemLazy_load.runLoadHooks('Ember.Application', _emberApplicationSystemApplication.default); -}); - -/** -@module ember -@submodule ember-application -*/ enifed('ember-debug/deprecate', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-metal/logger', 'ember-debug/handlers'], function (exports, _emberMetalCore, _emberMetalError, _emberMetalLogger, _emberDebugHandlers) { /*global __fail__*/ 'use strict'; @@ -6129,86 +6310,13 @@ if (handlerForType) { handlerForType(message, options); } } }); -enifed('ember-debug/is-plain-function', ['exports'], function (exports) { +enifed('ember-debug/index', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/logger', 'ember-metal/environment', 'ember-debug/deprecate', 'ember-debug/warn', 'ember-debug/is-plain-function', 'ember-debug/handlers'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalLogger, _emberMetalEnvironment, _emberDebugDeprecate, _emberDebugWarn, _emberDebugIsPlainFunction, _emberDebugHandlers) { 'use strict'; - exports.default = isPlainFunction; - - function isPlainFunction(test) { - return typeof test === 'function' && test.PrototypeMixin === undefined; - } -}); -enifed('ember-debug/warn', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-debug/handlers'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberDebugHandlers) { - 'use strict'; - - var _slice = Array.prototype.slice; - exports.registerHandler = registerHandler; - exports.default = warn; - - function registerHandler(handler) { - _emberDebugHandlers.registerHandler('warn', handler); - } - - registerHandler(function logWarning(message, options) { - _emberMetalLogger.default.warn('WARNING: ' + message); - if ('trace' in _emberMetalLogger.default) { - _emberMetalLogger.default.trace(); - } - }); - - var missingOptionsDeprecation = 'When calling `Ember.warn` you ' + 'must provide an `options` hash as the third parameter. ' + '`options` should include an `id` property.'; - exports.missingOptionsDeprecation = missingOptionsDeprecation; - var missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.'; - - exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation; - /** - @module ember - @submodule ember-debug - */ - - /** - Display a warning with the provided message. Ember build tools will - remove any calls to `Ember.warn()` when doing a production build. - - @method warn - @param {String} message A warning to display. - @param {Boolean} test An optional boolean. If falsy, the warning - will be displayed. - @param {Object} options An ojbect that can be used to pass a unique - `id` for this warning. The `id` can be used by Ember debugging tools - to change the behavior (raise, log, or silence) for that specific warning. - The `id` should be namespaced by dots, e.g. "ember-debug.feature-flag-with-features-stripped" - @for Ember - @public - */ - - function warn(message, test, options) { - if (!options) { - _emberMetalDebug.deprecate(missingOptionsDeprecation, false, { - id: 'ember-debug.warn-options-missing', - until: '3.0.0', - url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' - }); - } - - if (options && !options.id) { - _emberMetalDebug.deprecate(missingOptionsIdDeprecation, false, { - id: 'ember-debug.warn-id-missing', - until: '3.0.0', - url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' - }); - } - - _emberDebugHandlers.invoke.apply(undefined, ['warn'].concat(_slice.call(arguments))); - } -}); -enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/logger', 'ember-metal/environment', 'ember-debug/deprecate', 'ember-debug/warn', 'ember-debug/is-plain-function', 'ember-debug/handlers'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalLogger, _emberMetalEnvironment, _emberDebugDeprecate, _emberDebugWarn, _emberDebugIsPlainFunction, _emberDebugHandlers) { - 'use strict'; - exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags; /** @module ember @submodule ember-debug @@ -6496,10 +6604,83 @@ exports.runningNonEmberDebugJS = runningNonEmberDebugJS; if (runningNonEmberDebugJS) { _emberMetalDebug.warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.'); } }); +enifed('ember-debug/is-plain-function', ['exports'], function (exports) { + 'use strict'; + + exports.default = isPlainFunction; + + function isPlainFunction(test) { + return typeof test === 'function' && test.PrototypeMixin === undefined; + } +}); +enifed('ember-debug/warn', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-debug/handlers'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberDebugHandlers) { + 'use strict'; + + var _slice = Array.prototype.slice; + exports.registerHandler = registerHandler; + exports.default = warn; + + function registerHandler(handler) { + _emberDebugHandlers.registerHandler('warn', handler); + } + + registerHandler(function logWarning(message, options) { + _emberMetalLogger.default.warn('WARNING: ' + message); + if ('trace' in _emberMetalLogger.default) { + _emberMetalLogger.default.trace(); + } + }); + + var missingOptionsDeprecation = 'When calling `Ember.warn` you ' + 'must provide an `options` hash as the third parameter. ' + '`options` should include an `id` property.'; + exports.missingOptionsDeprecation = missingOptionsDeprecation; + var missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.'; + + exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation; + /** + @module ember + @submodule ember-debug + */ + + /** + Display a warning with the provided message. Ember build tools will + remove any calls to `Ember.warn()` when doing a production build. + + @method warn + @param {String} message A warning to display. + @param {Boolean} test An optional boolean. If falsy, the warning + will be displayed. + @param {Object} options An ojbect that can be used to pass a unique + `id` for this warning. The `id` can be used by Ember debugging tools + to change the behavior (raise, log, or silence) for that specific warning. + The `id` should be namespaced by dots, e.g. "ember-debug.feature-flag-with-features-stripped" + @for Ember + @public + */ + + function warn(message, test, options) { + if (!options) { + _emberMetalDebug.deprecate(missingOptionsDeprecation, false, { + id: 'ember-debug.warn-options-missing', + until: '3.0.0', + url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' + }); + } + + if (options && !options.id) { + _emberMetalDebug.deprecate(missingOptionsIdDeprecation, false, { + id: 'ember-debug.warn-id-missing', + until: '3.0.0', + url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' + }); + } + + _emberDebugHandlers.invoke.apply(undefined, ['warn'].concat(_slice.call(arguments))); + } +}); enifed('ember-extension-support/container_debug_adapter', ['exports', 'ember-metal/core', 'ember-runtime/system/native_array', 'ember-runtime/utils', 'ember-runtime/system/string', 'ember-runtime/system/namespace', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberRuntimeSystemNative_array, _emberRuntimeUtils, _emberRuntimeSystemString, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject) { 'use strict'; /** @module ember @@ -7078,11 +7259,11 @@ observeRecord: function (record, recordUpdated) { return function () {}; } }); }); -enifed('ember-extension-support', ['exports', 'ember-metal/core', 'ember-extension-support/data_adapter', 'ember-extension-support/container_debug_adapter'], function (exports, _emberMetalCore, _emberExtensionSupportData_adapter, _emberExtensionSupportContainer_debug_adapter) { +enifed('ember-extension-support/index', ['exports', 'ember-metal/core', 'ember-extension-support/data_adapter', 'ember-extension-support/container_debug_adapter'], function (exports, _emberMetalCore, _emberExtensionSupportData_adapter, _emberExtensionSupportContainer_debug_adapter) { /** @module ember @submodule ember-extension-support */ @@ -7724,11 +7905,11 @@ 'use strict'; /** Use the `if` block helper to conditionally render a block depending on a property. If the property is "falsey", for example: `false`, `undefined`, - `null`, `""`, `0` or an empty array, the block will not be rendered. + `null`, `""`, `0`, `NaN` or an empty array, the block will not be rendered. ```handlebars {{! will not render if foo is falsey}} {{#if foo}} Welcome to the {{foo.bar}} @@ -8163,11 +8344,11 @@ if (renderNode.cleanup) { renderNode.cleanup(); } } }); -enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember-htmlbars/node-managers/component-node-manager', 'ember-views/system/build-component-template', 'ember-htmlbars/utils/lookup-component', 'ember-metal/assign', 'ember-metal/empty_object', 'ember-metal/cache', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component'], function (exports, _emberMetalDebug, _emberHtmlbarsNodeManagersComponentNodeManager, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsUtilsLookupComponent, _emberMetalAssign, _emberMetalEmpty_object, _emberMetalCache, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent) { +enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/features', 'ember-metal/debug', 'ember-htmlbars/node-managers/component-node-manager', 'ember-views/system/build-component-template', 'ember-htmlbars/utils/lookup-component', 'ember-metal/assign', 'ember-metal/empty_object', 'ember-metal/cache', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component'], function (exports, _emberMetalFeatures, _emberMetalDebug, _emberHtmlbarsNodeManagersComponentNodeManager, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsUtilsLookupComponent, _emberMetalAssign, _emberMetalEmpty_object, _emberMetalCache, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent) { 'use strict'; exports.default = componentHook; var IS_ANGLE_CACHE = new _emberMetalCache.default(1000, function (key) { @@ -8252,11 +8433,14 @@ var isNormalHTMLElement = isAngleBracket && !isDasherized && isInvokedWithCurlies; var component = undefined, layout = undefined; if (isDasherized || !isAngleBracket) { - var result = _emberHtmlbarsUtilsLookupComponent.default(env.owner, tagName); + var options = {}; + + var result = _emberHtmlbarsUtilsLookupComponent.default(env.owner, tagName, options); + component = result.component; layout = result.layout; if (isAngleBracket && isDasherized && !component && !layout) { isComponentHTMLElement = true; @@ -8747,10 +8931,20 @@ if (_emberHtmlbarsSystemLookupHelper.validateLazyHelperName(helperName, owner, env.hooks.keywords)) { var registrationName = 'helper:' + helperName; if (owner.hasRegistration(registrationName)) { return true; } + + var options = {}; + var moduleName = env.meta && env.meta.moduleName; + if (moduleName) { + options.source = 'template:' + moduleName; + } + + if (owner.hasRegistration(registrationName, options)) { + return true; + } } return false; } }); @@ -9042,10 +9236,162 @@ // untouched. This view is then cleared once cleanup is complete in // `didCleanupTree`. view.ownerView._destroyingSubtreeForView = view; } }); +enifed('ember-htmlbars/index', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers', 'ember-htmlbars/helpers/if_unless', 'ember-htmlbars/helpers/with', 'ember-htmlbars/helpers/loc', 'ember-htmlbars/helpers/log', 'ember-htmlbars/helpers/each', 'ember-htmlbars/helpers/each-in', 'ember-htmlbars/helpers/-normalize-class', 'ember-htmlbars/helpers/-concat', 'ember-htmlbars/helpers/-join-classes', 'ember-htmlbars/helpers/-legacy-each-with-controller', 'ember-htmlbars/helpers/-legacy-each-with-keyword', 'ember-htmlbars/helpers/-html-safe', 'ember-htmlbars/helpers/hash', 'ember-htmlbars/system/dom-helper', 'ember-htmlbars/helper', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/template_registry', 'ember-htmlbars/system/bootstrap', 'ember-htmlbars/compat'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler, _emberHtmlbarsSystemMake_bound_helper, _emberHtmlbarsHelpers, _emberHtmlbarsHelpersIf_unless, _emberHtmlbarsHelpersWith, _emberHtmlbarsHelpersLoc, _emberHtmlbarsHelpersLog, _emberHtmlbarsHelpersEach, _emberHtmlbarsHelpersEachIn, _emberHtmlbarsHelpersNormalizeClass, _emberHtmlbarsHelpersConcat, _emberHtmlbarsHelpersJoinClasses, _emberHtmlbarsHelpersLegacyEachWithController, _emberHtmlbarsHelpersLegacyEachWithKeyword, _emberHtmlbarsHelpersHtmlSafe, _emberHtmlbarsHelpersHash, _emberHtmlbarsSystemDomHelper, _emberHtmlbarsHelper, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsTemplate_registry, _emberHtmlbarsSystemBootstrap, _emberHtmlbarsCompat) { + /** + Ember templates are executed by [HTMLBars](https://github.com/tildeio/htmlbars), + an HTML-friendly version of [Handlebars](http://handlebarsjs.com/). Any valid Handlebars syntax is valid in an Ember template. + + ### Showing a property + + Templates manage the flow of an application's UI, and display state (through + the DOM) to a user. For example, given a component with the property "name", + that component's template can use the name in several ways: + + ```javascript + // app/components/person.js + export default Ember.Component.extend({ + name: 'Jill' + }); + ``` + + ```handlebars + {{! app/components/person.hbs }} + {{name}} + <div>{{name}}</div> + <span data-name={{name}}></span> + ``` + + Any time the "name" property on the component changes, the DOM will be + updated. + + Properties can be chained as well: + + ```handlebars + {{aUserModel.name}} + <div>{{listOfUsers.firstObject.name}}</div> + ``` + + ### Using Ember helpers + + When content is passed in mustaches `{{}}`, Ember will first try to find a helper + or component with that name. For example, the `if` helper: + + ```handlebars + {{if name "I have a name" "I have no name"}} + <span data-has-name={{if name true}}></span> + ``` + + The returned value is placed where the `{{}}` is called. The above style is + called "inline". A second style of helper usage is called "block". For example: + + ```handlebars + {{#if name}} + I have a name + {{else}} + I have no name + {{/if}} + ``` + + The block form of helpers allows you to control how the UI is created based + on the values of properties. + + A third form of helper is called "nested". For example here the concat + helper will add " Doe" to a displayed name if the person has no last name: + + ```handlebars + <span data-name={{concat firstName ( + if lastName (concat " " lastName) "Doe" + )}}></span> + ``` + + Ember's built-in helpers are described under the [Ember.Templates.helpers](/api/classes/Ember.Templates.helpers.html) + namespace. Documentation on creating custom helpers can be found under + [Ember.Helper](/api/classes/Ember.Helper.html). + + ### Invoking a Component + + Ember components represent state to the UI of an application. Further + reading on components can be found under [Ember.Component](/api/classes/Ember.Component.html). + + @module ember + @submodule ember-templates + @main ember-templates + @public + */ + + /** + + [HTMLBars](https://github.com/tildeio/htmlbars) is a [Handlebars](http://handlebarsjs.com/) + compatible templating engine used by Ember.js. The classes and namespaces + covered by this documentation attempt to focus on APIs for interacting + with HTMLBars itself. For more general guidance on Ember.js templates and + helpers, please see the [ember-templates](/api/modules/ember-templates.html) + package. + + @module ember + @submodule ember-htmlbars + @main ember-htmlbars + @public + */ + 'use strict'; + + _emberHtmlbarsHelpers.registerHelper('if', _emberHtmlbarsHelpersIf_unless.ifHelper); + _emberHtmlbarsHelpers.registerHelper('unless', _emberHtmlbarsHelpersIf_unless.unlessHelper); + _emberHtmlbarsHelpers.registerHelper('with', _emberHtmlbarsHelpersWith.default); + _emberHtmlbarsHelpers.registerHelper('loc', _emberHtmlbarsHelpersLoc.default); + _emberHtmlbarsHelpers.registerHelper('log', _emberHtmlbarsHelpersLog.default); + _emberHtmlbarsHelpers.registerHelper('each', _emberHtmlbarsHelpersEach.default); + _emberHtmlbarsHelpers.registerHelper('each-in', _emberHtmlbarsHelpersEachIn.default); + _emberHtmlbarsHelpers.registerHelper('-normalize-class', _emberHtmlbarsHelpersNormalizeClass.default); + _emberHtmlbarsHelpers.registerHelper('concat', _emberHtmlbarsHelpersConcat.default); + _emberHtmlbarsHelpers.registerHelper('-join-classes', _emberHtmlbarsHelpersJoinClasses.default); + _emberHtmlbarsHelpers.registerHelper('-html-safe', _emberHtmlbarsHelpersHtmlSafe.default); + + _emberHtmlbarsHelpers.registerHelper('hash', _emberHtmlbarsHelpersHash.default); + + if (_emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-controller', _emberHtmlbarsHelpersLegacyEachWithController.default); + _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-keyword', _emberHtmlbarsHelpersLegacyEachWithKeyword.default); + } + + _emberMetalCore.default.HTMLBars = { + template: _emberTemplateCompiler.template, + compile: _emberTemplateCompiler.compile, + precompile: _emberTemplateCompiler.precompile, + makeBoundHelper: _emberHtmlbarsSystemMake_bound_helper.default, + registerPlugin: _emberTemplateCompiler.registerPlugin, + DOMHelper: _emberHtmlbarsSystemDomHelper.default + }; + + _emberHtmlbarsHelper.default.helper = _emberHtmlbarsHelper.helper; + _emberMetalCore.default.Helper = _emberHtmlbarsHelper.default; + + /** + Global hash of shared templates. This will automatically be populated + by the build tools so that you can store your Handlebars templates in + separate files that get loaded into JavaScript at buildtime. + + @property TEMPLATES + @for Ember + @type Object + @private + */ + Object.defineProperty(_emberMetalCore.default, 'TEMPLATES', { + configurable: false, + get: _emberHtmlbarsTemplate_registry.getTemplates, + set: _emberHtmlbarsTemplate_registry.setTemplates + }); +}); + +// importing adds template bootstrapping +// initializer to enable embedded templates + +// importing ember-htmlbars/compat updates the +// Ember.Handlebars global if htmlbars is enabled enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/debug', 'ember-metal/is_none', 'ember-metal/symbol', 'ember-metal/streams/stream', 'ember-metal/empty_object', 'ember-metal/streams/utils', 'ember-htmlbars/hooks/subexpr', 'ember-metal/assign', 'ember-htmlbars/utils/extract-positional-params', 'ember-htmlbars/utils/lookup-component'], function (exports, _emberMetalDebug, _emberMetalIs_none, _emberMetalSymbol, _emberMetalStreamsStream, _emberMetalEmpty_object, _emberMetalStreamsUtils, _emberHtmlbarsHooksSubexpr, _emberMetalAssign, _emberHtmlbarsUtilsExtractPositionalParams, _emberHtmlbarsUtilsLookupComponent) { /** @module ember @submodule ember-templates */ @@ -9365,11 +9711,11 @@ } return viewClassOrInstance; } }); -enifed('ember-htmlbars/keywords/component', ['exports', 'htmlbars-runtime/hooks', 'ember-htmlbars/keywords/closure-component', 'ember-metal/features'], function (exports, _htmlbarsRuntimeHooks, _emberHtmlbarsKeywordsClosureComponent, _emberMetalFeatures) { +enifed('ember-htmlbars/keywords/component', ['exports', 'htmlbars-runtime/hooks', 'ember-htmlbars/keywords/closure-component', 'ember-metal/features', 'ember-metal/empty_object', 'ember-metal/assign'], function (exports, _htmlbarsRuntimeHooks, _emberHtmlbarsKeywordsClosureComponent, _emberMetalFeatures, _emberMetalEmpty_object, _emberMetalAssign) { /** @module ember @submodule ember-templates @public */ @@ -9445,15 +9791,18 @@ @for Ember.Templates.helpers @public */ exports.default = function (morph, env, scope, params, hash, template, inverse, visitor) { - if (morph) { - _htmlbarsRuntimeHooks.keyword('@element_component', morph, env, scope, params, hash, template, inverse, visitor); - return true; + if (!morph) { + return _emberHtmlbarsKeywordsClosureComponent.default(env, params, hash); } - return _emberHtmlbarsKeywordsClosureComponent.default(env, params, hash); + + var newHash = _emberMetalAssign.default(new _emberMetalEmpty_object.default(), hash); + + _htmlbarsRuntimeHooks.keyword('@element_component', morph, env, scope, params, newHash, template, inverse, visitor); + return true; }; }); enifed('ember-htmlbars/keywords/debugger', ['exports', 'ember-metal/debug'], function (exports, _emberMetalDebug) { /*jshint debug:true*/ @@ -9554,11 +9903,11 @@ } return false; } }); -enifed('ember-htmlbars/keywords/element-component', ['exports', 'ember-metal/assign', 'ember-htmlbars/keywords/closure-component'], function (exports, _emberMetalAssign, _emberHtmlbarsKeywordsClosureComponent) { +enifed('ember-htmlbars/keywords/element-component', ['exports', 'ember-metal/assign', 'ember-htmlbars/keywords/closure-component', 'ember-htmlbars/utils/lookup-component', 'ember-htmlbars/utils/extract-positional-params'], function (exports, _emberMetalAssign, _emberHtmlbarsKeywordsClosureComponent, _emberHtmlbarsUtilsLookupComponent, _emberHtmlbarsUtilsExtractPositionalParams) { 'use strict'; exports.default = { setupState: function (lastState, env, scope, params, hash) { var componentPath = getComponentPath(params[0], env); @@ -9601,10 +9950,12 @@ function render(morph, env, scope, _ref, hash, template, inverse, visitor) { var path = _ref[0]; var params = _ref.slice(1); + var isRerender = arguments.length <= 8 || arguments[8] === undefined ? false : arguments[8]; + var _morph$getState = morph.getState(); var componentPath = _morph$getState.componentPath; // If the value passed to the {{component}} helper is undefined or null, @@ -9613,10 +9964,17 @@ return; } path = env.hooks.getValue(path); + if (isRerender) { + var result = _emberHtmlbarsUtilsLookupComponent.default(env.owner, componentPath); + var component = result.component; + + _emberHtmlbarsUtilsExtractPositionalParams.default(null, component, params, hash); + } + if (_emberHtmlbarsKeywordsClosureComponent.isComponentCell(path)) { var closureComponent = env.hooks.getValue(path); // This needs to be done in each nesting level to avoid raising assertions _emberHtmlbarsKeywordsClosureComponent.processPositionalParamsFromCell(closureComponent, params, hash); @@ -10135,11 +10493,11 @@ @submodule ember-templates */ 'use strict'; - _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.3.2'; + _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.4.0-beta.2'; /** The `{{outlet}}` helper lets you specify where a child routes will render in your template. An important use of the `{{outlet}}` helper is in your application's `application.hbs` file: @@ -10217,11 +10575,15 @@ manager: state.manager }; }, childEnv: function (state, env) { - return env.childWithOutletState(state.outletState && state.outletState.outlets, true); + var outletState = state.outletState; + var toRender = outletState && outletState.render; + var meta = toRender && toRender.template && toRender.template.meta; + + return env.childWithOutletState(outletState && outletState.outlets, true, meta); }, isStable: function (lastState, nextState) { return isStable(lastState.outletState, nextState.outletState); }, @@ -11277,11 +11639,12 @@ ComponentNodeManager.prototype.render = function ComponentNodeManager_render(_env, visitor) { var component = this.component; return _emberHtmlbarsSystemInstrumentationSupport.instrument(component, function ComponentNodeManager_render_instrument() { - var env = _env.childWithView(component); + var meta = this.block && this.block.template.meta; + var env = _env.childWithView(component, meta); env.renderer.componentWillRender(component); env.renderedViews.push(component.elementId); if (this.block) { @@ -11534,10 +11897,14 @@ return _emberHtmlbarsSystemInstrumentationSupport.instrument(component, function ViewNodeManager_render_instrument() { var newEnv = env; if (component) { newEnv = env.childWithView(component); + } else { + var meta = this.block && this.block.template.meta; + + newEnv = env.childWithMeta(meta); } if (component) { env.renderer.willRender(component); env.renderedViews.push(component.elementId); @@ -11584,11 +11951,16 @@ } env.renderer.willRender(component); env.renderedViews.push(component.elementId); + } else { + var meta = this.block && this.block.template.meta; + + newEnv = env.childWithMeta(meta); } + if (this.block) { this.block.invoke(newEnv, [], undefined, this.renderNode, this.scope, visitor); } return newEnv; @@ -11630,11 +12002,11 @@ _emberMetalAssign.default(props, createOptions); } mergeBindings(props, snapshot); - var owner = options.parentView ? _containerOwner.getOwner(options.parentView) : env.owner; + var owner = env.owner; _containerOwner.setOwner(props, owner); props.renderer = options.parentView ? options.parentView.renderer : owner && owner.lookup('renderer:-dom'); props._viewRegistry = options.parentView ? options.parentView._viewRegistry : owner && owner.lookup('-view-registry:main'); @@ -11860,11 +12232,11 @@ */ /** Find templates stored in the head tag as script tags and make them available to `Ember.CoreView` in the global `Ember.TEMPLATES` object. This will be run - as as jQuery DOM-ready callback. + as a jQuery DOM-ready callback. Script tags with `text/x-handlebars` will be compiled with Ember's template compiler and are suitable for use as a view's template. Those with type `text/x-raw-handlebars` will be compiled with regular Handlebars and are suitable for use in views' computed properties. @@ -12004,12 +12376,13 @@ 'use strict'; exports.buildHelperStream = buildHelperStream; function buildHelperStream(helper, params, hash, templates, env, scope, label) { - _emberMetalDebug.assert('Helpers may not be used in the block form, for example {{#my-helper}}{{/my-helper}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (my-helper)}}{{/if}}.', !(helper.isHelperInstance && !helper.isHelperFactory) || !templates || !templates.template || !templates.template.meta); - _emberMetalDebug.assert('Helpers may not be used in the element form, for example <div {{my-helper}}>.', !(helper.isHelperInstance && !helper.isHelperFactory) || !templates || !templates.element); + var isAnyKindOfHelper = helper.isHelperInstance || helper.isHelperFactory; + _emberMetalDebug.assert('Helpers may not be used in the block form, for example {{#my-helper}}{{/my-helper}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (my-helper)}}{{/if}}.', !(isAnyKindOfHelper && templates && templates.template && templates.template.meta)); + _emberMetalDebug.assert('Helpers may not be used in the element form, for example <div {{my-helper}}>.', !(isAnyKindOfHelper && templates && templates.element)); if (helper.isHelperFactory) { return new _emberHtmlbarsStreamsHelperFactory.default(helper, params, hash, label); } else if (helper.isHelperInstance) { return new _emberHtmlbarsStreamsHelperInstance.default(helper, params, hash, label); } else { @@ -12056,31 +12429,45 @@ @private @method resolveHelper @param {String} name the name of the helper to lookup @return {Helper} */ - - function findHelper(name, view, env) { + function _findHelper(name, view, env, options) { var helper = env.helpers[name]; if (!helper) { var owner = env.owner; if (validateLazyHelperName(name, owner, env.hooks.keywords)) { var helperName = 'helper:' + name; - // See https://github.com/emberjs/ember.js/issues/13071 - // See https://bugs.chromium.org/p/v8/issues/detail?id=4839 - var registered = owner.hasRegistration(helperName); - if (registered) { - helper = owner._lookupFactory(helperName); + if (owner.hasRegistration(helperName, options)) { + helper = owner._lookupFactory(helperName, options); _emberMetalDebug.assert('Expected to find an Ember.Helper with the name ' + helperName + ', but found an object of type ' + typeof helper + ' instead.', helper.isHelperFactory || helper.isHelperInstance); } } } return helper; } + function findHelper(name, view, env) { + var options = {}; + var moduleName = env.meta && env.meta.moduleName; + if (moduleName) { + options.source = 'template:' + moduleName; + } + + var localHelper = _findHelper(name, view, env, options); + + // local match found, use it + if (localHelper) { + return localHelper; + } + + // fallback to global + return _findHelper(name, view, env); + } + function lookupHelper(name, view, env) { var helper = findHelper(name, view, env); _emberMetalDebug.assert('A helper named \'' + name + '\' could not be found', !!helper); @@ -12159,54 +12546,76 @@ this.view = options.view; this.outletState = options.outletState; this.owner = options.owner; this.renderer = options.renderer; this.dom = options.dom; + this.meta = options.meta; this.hooks = _emberHtmlbarsEnv.default.hooks; this.helpers = _emberHtmlbarsEnv.default.helpers; this.useFragmentCache = _emberHtmlbarsEnv.default.useFragmentCache; this.destinedForDOM = this.renderer._destinedForDOM; } - RenderEnv.build = function (view) { + RenderEnv.build = function (view, meta) { return new RenderEnv({ view: view, outletState: view.outletState, owner: _containerOwner.getOwner(view), renderer: view.renderer, - dom: view.renderer._dom + dom: view.renderer._dom, + meta: meta }); }; + RenderEnv.prototype.childWithMeta = function (meta) { + return new RenderEnv({ + view: this.view, + outletState: this.outletState, + owner: this.owner, + renderer: this.renderer, + dom: this.dom, + lifecycleHooks: this.lifecycleHooks, + renderedViews: this.renderedViews, + renderedNodes: this.renderedNodes, + hasParentOutlet: this.hasParentOutlet, + meta: meta + }); + }; + RenderEnv.prototype.childWithView = function (view) { + var meta = arguments.length <= 1 || arguments[1] === undefined ? this.meta : arguments[1]; + return new RenderEnv({ view: view, outletState: this.outletState, owner: this.owner, renderer: this.renderer, dom: this.dom, lifecycleHooks: this.lifecycleHooks, renderedViews: this.renderedViews, renderedNodes: this.renderedNodes, - hasParentOutlet: this.hasParentOutlet + hasParentOutlet: this.hasParentOutlet, + meta: meta }); }; RenderEnv.prototype.childWithOutletState = function (outletState) { var hasParentOutlet = arguments.length <= 1 || arguments[1] === undefined ? this.hasParentOutlet : arguments[1]; + var meta = arguments.length <= 2 || arguments[2] === undefined ? this.meta : arguments[2]; return new RenderEnv({ view: this.view, outletState: outletState, owner: this.owner, renderer: this.renderer, dom: this.dom, lifecycleHooks: this.lifecycleHooks, renderedViews: this.renderedViews, renderedNodes: this.renderedNodes, - hasParentOutlet: hasParentOutlet + hasParentOutlet: hasParentOutlet, + meta: meta }); }; }); enifed('ember-htmlbars/system/render-view', ['exports', 'ember-htmlbars/node-managers/view-node-manager', 'ember-htmlbars/system/render-env'], function (exports, _emberHtmlbarsNodeManagersViewNodeManager, _emberHtmlbarsSystemRenderEnv) { 'use strict'; @@ -12215,11 +12624,12 @@ // This function only gets called once per render of a "root view" (`appendTo`). Otherwise, // HTMLBars propagates the existing env and renders templates for a given render node. function renderHTMLBarsBlock(view, block, renderNode) { - var env = _emberHtmlbarsSystemRenderEnv.default.build(view); + var meta = block && block.template && block.template.meta; + var env = _emberHtmlbarsSystemRenderEnv.default.build(view, meta); view.env = env; _emberHtmlbarsNodeManagersViewNodeManager.createOrUpdateComponent(view, {}, null, renderNode, env); var nodeManager = new _emberHtmlbarsNodeManagersViewNodeManager.default(view, null, renderNode, block, view.tagName !== ''); @@ -13171,20 +13581,24 @@ var param = params[i]; paramsStream.addDependency(param); } } }); -enifed('ember-htmlbars/utils/is-component', ['exports', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component', 'ember-metal/streams/utils'], function (exports, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent, _emberMetalStreamsUtils) { +enifed('ember-htmlbars/utils/is-component', ['exports', 'ember-metal/features', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component', 'ember-metal/streams/utils'], function (exports, _emberMetalFeatures, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent, _emberMetalStreamsUtils) { /** @module ember @submodule ember-htmlbars */ 'use strict'; exports.default = isComponent; + function hasComponentOrTemplate(owner, path, options) { + return owner.hasRegistration('component:' + path, options) || owner.hasRegistration('template:components/' + path, options); + } + /* Given a path name, returns whether or not a component with that name was found in the container. */ @@ -13204,27 +13618,38 @@ } } if (!_emberHtmlbarsSystemLookupHelper.CONTAINS_DASH_CACHE.get(path)) { return false; } - return owner.hasRegistration('component:' + path) || owner.hasRegistration('template:components/' + path); + + if (hasComponentOrTemplate(owner, path)) { + return true; // global component found + } else { + return false; + } } } }); -enifed('ember-htmlbars/utils/lookup-component', ['exports'], function (exports) { + +// without a source moduleName we can not perform local lookups +enifed('ember-htmlbars/utils/lookup-component', ['exports', 'ember-metal/features'], function (exports, _emberMetalFeatures) { 'use strict'; exports.default = lookupComponent; - function lookupComponent(container, tagName) { - var componentLookup = container.lookup('component-lookup:main'); - + function lookupComponentPair(componentLookup, owner, tagName, options) { return { - component: componentLookup.componentFor(tagName, container), - layout: componentLookup.layoutFor(tagName, container) + component: componentLookup.componentFor(tagName, owner, options), + layout: componentLookup.layoutFor(tagName, owner, options) }; } + + function lookupComponent(owner, tagName, options) { + var componentLookup = owner.lookup('component-lookup:main'); + + return lookupComponentPair(componentLookup, owner, tagName); + } }); enifed('ember-htmlbars/utils/new-stream', ['exports', 'ember-metal/streams/proxy-stream', 'ember-htmlbars/utils/subscribe'], function (exports, _emberMetalStreamsProxyStream, _emberHtmlbarsUtilsSubscribe) { 'use strict'; exports.default = newStream; @@ -13342,162 +13767,10 @@ } scope[key] = stream; } } }); -enifed('ember-htmlbars', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers', 'ember-htmlbars/helpers/if_unless', 'ember-htmlbars/helpers/with', 'ember-htmlbars/helpers/loc', 'ember-htmlbars/helpers/log', 'ember-htmlbars/helpers/each', 'ember-htmlbars/helpers/each-in', 'ember-htmlbars/helpers/-normalize-class', 'ember-htmlbars/helpers/-concat', 'ember-htmlbars/helpers/-join-classes', 'ember-htmlbars/helpers/-legacy-each-with-controller', 'ember-htmlbars/helpers/-legacy-each-with-keyword', 'ember-htmlbars/helpers/-html-safe', 'ember-htmlbars/helpers/hash', 'ember-htmlbars/system/dom-helper', 'ember-htmlbars/helper', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/template_registry', 'ember-htmlbars/system/bootstrap', 'ember-htmlbars/compat'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler, _emberHtmlbarsSystemMake_bound_helper, _emberHtmlbarsHelpers, _emberHtmlbarsHelpersIf_unless, _emberHtmlbarsHelpersWith, _emberHtmlbarsHelpersLoc, _emberHtmlbarsHelpersLog, _emberHtmlbarsHelpersEach, _emberHtmlbarsHelpersEachIn, _emberHtmlbarsHelpersNormalizeClass, _emberHtmlbarsHelpersConcat, _emberHtmlbarsHelpersJoinClasses, _emberHtmlbarsHelpersLegacyEachWithController, _emberHtmlbarsHelpersLegacyEachWithKeyword, _emberHtmlbarsHelpersHtmlSafe, _emberHtmlbarsHelpersHash, _emberHtmlbarsSystemDomHelper, _emberHtmlbarsHelper, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsTemplate_registry, _emberHtmlbarsSystemBootstrap, _emberHtmlbarsCompat) { - /** - Ember templates are executed by [HTMLBars](https://github.com/tildeio/htmlbars), - an HTML-friendly version of [Handlebars](http://handlebarsjs.com/). Any valid Handlebars syntax is valid in an Ember template. - - ### Showing a property - - Templates manage the flow of an application's UI, and display state (through - the DOM) to a user. For example, given a component with the property "name", - that component's template can use the name in several ways: - - ```javascript - // app/components/person.js - export default Ember.Component.extend({ - name: 'Jill' - }); - ``` - - ```handlebars - {{! app/components/person.hbs }} - {{name}} - <div>{{name}}</div> - <span data-name={{name}}></span> - ``` - - Any time the "name" property on the component changes, the DOM will be - updated. - - Properties can be chained as well: - - ```handlebars - {{aUserModel.name}} - <div>{{listOfUsers.firstObject.name}}</div> - ``` - - ### Using Ember helpers - - When content is passed in mustaches `{{}}`, Ember will first try to find a helper - or component with that name. For example, the `if` helper: - - ```handlebars - {{if name "I have a name" "I have no name"}} - <span data-has-name={{if name true}}></span> - ``` - - The returned value is placed where the `{{}}` is called. The above style is - called "inline". A second style of helper usage is called "block". For example: - - ```handlebars - {{#if name}} - I have a name - {{else}} - I have no name - {{/if}} - ``` - - The block form of helpers allows you to control how the UI is created based - on the values of properties. - - A third form of helper is called "nested". For example here the concat - helper will add " Doe" to a displayed name if the person has no last name: - - ```handlebars - <span data-name={{concat firstName ( - if lastName (concat " " lastName) "Doe" - )}}></span> - ``` - - Ember's built-in helpers are described under the [Ember.Templates.helpers](/api/classes/Ember.Templates.helpers.html) - namespace. Documentation on creating custom helpers can be found under - [Ember.Helper](/api/classes/Ember.Helper.html). - - ### Invoking a Component - - Ember components represent state to the UI of an application. Further - reading on components can be found under [Ember.Component](/api/classes/Ember.Component.html). - - @module ember - @submodule ember-templates - @main ember-templates - @public - */ - - /** - - [HTMLBars](https://github.com/tildeio/htmlbars) is a [Handlebars](http://handlebarsjs.com/) - compatible templating engine used by Ember.js. The classes and namespaces - covered by this documentation attempt to focus on APIs for interacting - with HTMLBars itself. For more general guidance on Ember.js templates and - helpers, please see the [ember-templates](/api/modules/ember-templates.html) - package. - - @module ember - @submodule ember-htmlbars - @main ember-htmlbars - @public - */ - 'use strict'; - - _emberHtmlbarsHelpers.registerHelper('if', _emberHtmlbarsHelpersIf_unless.ifHelper); - _emberHtmlbarsHelpers.registerHelper('unless', _emberHtmlbarsHelpersIf_unless.unlessHelper); - _emberHtmlbarsHelpers.registerHelper('with', _emberHtmlbarsHelpersWith.default); - _emberHtmlbarsHelpers.registerHelper('loc', _emberHtmlbarsHelpersLoc.default); - _emberHtmlbarsHelpers.registerHelper('log', _emberHtmlbarsHelpersLog.default); - _emberHtmlbarsHelpers.registerHelper('each', _emberHtmlbarsHelpersEach.default); - _emberHtmlbarsHelpers.registerHelper('each-in', _emberHtmlbarsHelpersEachIn.default); - _emberHtmlbarsHelpers.registerHelper('-normalize-class', _emberHtmlbarsHelpersNormalizeClass.default); - _emberHtmlbarsHelpers.registerHelper('concat', _emberHtmlbarsHelpersConcat.default); - _emberHtmlbarsHelpers.registerHelper('-join-classes', _emberHtmlbarsHelpersJoinClasses.default); - _emberHtmlbarsHelpers.registerHelper('-html-safe', _emberHtmlbarsHelpersHtmlSafe.default); - - _emberHtmlbarsHelpers.registerHelper('hash', _emberHtmlbarsHelpersHash.default); - - if (_emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-controller', _emberHtmlbarsHelpersLegacyEachWithController.default); - _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-keyword', _emberHtmlbarsHelpersLegacyEachWithKeyword.default); - } - - _emberMetalCore.default.HTMLBars = { - template: _emberTemplateCompiler.template, - compile: _emberTemplateCompiler.compile, - precompile: _emberTemplateCompiler.precompile, - makeBoundHelper: _emberHtmlbarsSystemMake_bound_helper.default, - registerPlugin: _emberTemplateCompiler.registerPlugin, - DOMHelper: _emberHtmlbarsSystemDomHelper.default - }; - - _emberHtmlbarsHelper.default.helper = _emberHtmlbarsHelper.helper; - _emberMetalCore.default.Helper = _emberHtmlbarsHelper.default; - - /** - Global hash of shared templates. This will automatically be populated - by the build tools so that you can store your Handlebars templates in - separate files that get loaded into JavaScript at buildtime. - - @property TEMPLATES - @for Ember - @type Object - @private - */ - Object.defineProperty(_emberMetalCore.default, 'TEMPLATES', { - configurable: false, - get: _emberHtmlbarsTemplate_registry.getTemplates, - set: _emberHtmlbarsTemplate_registry.setTemplates - }); -}); - -// importing adds template bootstrapping -// initializer to enable embedded templates - -// importing ember-htmlbars/compat updates the -// Ember.Handlebars global if htmlbars is enabled enifed('ember-metal/alias', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/error', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/dependent_keys'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalError, _emberMetalProperties, _emberMetalComputed, _emberMetalUtils, _emberMetalMeta, _emberMetalDependent_keys) { 'use strict'; exports.default = alias; exports.AliasedProperty = AliasedProperty; @@ -14195,13 +14468,13 @@ revalidate: function (key) { this.notify(key, true, undefined); }, // key: the string key that is part of a path changed - // revalidate: boolean the chains that are watching this value should revalidate - // callback: function that will be called with the the object and path that - // will be/are invalidated by this key change depending on the + // revalidate: boolean; the chains that are watching this value should revalidate + // callback: function that will be called with the object and path that + // will be/are invalidated by this key change, depending on // whether the revalidate flag is passed notify: function (key, revalidate, callback) { var nodes = this.chains[key]; if (nodes === undefined || nodes.length === 0) { return; @@ -14554,10 +14827,12 @@ @submodule ember-metal */ function UNDEFINED() {} + var DEEP_EACH_REGEX = /\.@each\.[^.]+\./; + // .......................................................... // COMPUTED PROPERTY // /** @@ -14781,10 +15056,11 @@ */ ComputedPropertyPrototype.property = function () { var args; var addArg = function (property) { + _emberMetalDebug.warn('Dependent keys containing @each only work one level deep. ' + 'You cannot use nested forms like todos.@each.owner.name or todos.@each.owner.@each.name. ' + 'Please create an intermediary computed property.', DEEP_EACH_REGEX.test(property) === false, { id: 'ember-metal.computed-deep-each' }); args.push(property); }; args = []; for (var i = 0, l = arguments.length; i < l; i++) { @@ -15861,13 +16137,15 @@ return value; } }); } }); -enifed('ember-metal/core', ['exports'], function (exports) { +enifed('ember-metal/core', ['exports', 'require'], function (exports, _require) { /*globals Ember:true,ENV,EmberENV */ + 'use strict'; + /** @module ember @submodule ember-metal */ @@ -15884,16 +16162,14 @@ cross-platform libraries such as jQuery. For more details, see [Ember-Runtime](http://emberjs.com/api/modules/ember-runtime.html). @class Ember @static - @version 2.3.2 + @version 2.4.0-beta.2 @public */ - 'use strict'; - if ('undefined' === typeof Ember) { // Create core object. Make it act like an instance of Ember.Namespace so that // objects assigned to it are given a sane string representation. Ember = {}; } @@ -15915,11 +16191,11 @@ return 'Ember'; }; // The debug functions are exported to globals with `require` to // prevent babel-plugin-filter-imports from removing them. - var debugModule = Ember.__loader.require('ember-metal/debug'); + var debugModule = _require.default('ember-metal/debug'); Ember.assert = debugModule.assert; Ember.warn = debugModule.warn; Ember.debug = debugModule.debug; Ember.deprecate = debugModule.deprecate; Ember.deprecateFunc = debugModule.deprecateFunc; @@ -15928,15 +16204,15 @@ /** The semantic version. @property VERSION @type String - @default '2.3.2' + @default '2.4.0-beta.2' @static @public */ - Ember.VERSION = '2.3.2'; + Ember.VERSION = '2.4.0-beta.2'; /** The hash of environment variables used to control various configuration settings. To specify your own or override default settings, add the desired properties to a global hash named `EmberENV` (or `ENV` for @@ -16198,22 +16474,28 @@ return _emberMetalProperty_get.get(this, newKey); } }); } }); -enifed('ember-metal/dictionary', ['exports'], function (exports) { +enifed('ember-metal/dictionary', ['exports', 'ember-metal/empty_object'], function (exports, _emberMetalEmpty_object) { + 'use strict'; + + exports.default = makeDictionary; + // the delete is meant to hint at runtimes that this object should remain in // dictionary mode. This is clearly a runtime specific hack, but currently it // appears worthwhile in some usecases. Please note, these deletes do increase // the cost of creation dramatically over a plain Object.create. And as this // only makes sense for long-lived dictionaries that aren't instantiated often. - 'use strict'; - exports.default = makeDictionary; - function makeDictionary(parent) { - var dict = Object.create(parent); + var dict; + if (parent === null) { + dict = new _emberMetalEmpty_object.default(); + } else { + dict = Object.create(parent); + } dict['_dict'] = null; delete dict['_dict']; return dict; } }); @@ -16830,10 +17112,222 @@ ret[propertyNames[i]] = _emberMetalProperty_get.get(obj, propertyNames[i]); } return ret; } }); +enifed('ember-metal/index', ['exports', 'require', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/assign', 'ember-metal/merge', 'ember-metal/instrumentation', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/error', 'ember-metal/cache', 'ember-metal/logger', 'ember-metal/property_get', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/property_set', 'ember-metal/map', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/watch_key', 'ember-metal/chains', 'ember-metal/watch_path', 'ember-metal/watching', 'ember-metal/expand_properties', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/computed_macros', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/run_loop', 'ember-metal/libraries', 'ember-metal/is_none', 'ember-metal/is_empty', 'ember-metal/is_blank', 'ember-metal/is_present', 'backburner'], function (exports, _require, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalAssign, _emberMetalMerge, _emberMetalInstrumentation, _emberMetalUtils, _emberMetalMeta, _emberMetalError, _emberMetalCache, _emberMetalLogger, _emberMetalProperty_get, _emberMetalEvents, _emberMetalObserver_set, _emberMetalProperty_events, _emberMetalProperties, _emberMetalProperty_set, _emberMetalMap, _emberMetalGet_properties, _emberMetalSet_properties, _emberMetalWatch_key, _emberMetalChains, _emberMetalWatch_path, _emberMetalWatching, _emberMetalExpand_properties, _emberMetalComputed, _emberMetalAlias, _emberMetalComputed_macros, _emberMetalObserver, _emberMetalMixin, _emberMetalBinding, _emberMetalRun_loop, _emberMetalLibraries, _emberMetalIs_none, _emberMetalIs_empty, _emberMetalIs_blank, _emberMetalIs_present, _backburner) { + /** + @module ember + @submodule ember-metal + */ + + // BEGIN IMPORTS + 'use strict'; + + _emberMetalComputed.computed.empty = _emberMetalComputed_macros.empty; + _emberMetalComputed.computed.notEmpty = _emberMetalComputed_macros.notEmpty; + _emberMetalComputed.computed.none = _emberMetalComputed_macros.none; + _emberMetalComputed.computed.not = _emberMetalComputed_macros.not; + _emberMetalComputed.computed.bool = _emberMetalComputed_macros.bool; + _emberMetalComputed.computed.match = _emberMetalComputed_macros.match; + _emberMetalComputed.computed.equal = _emberMetalComputed_macros.equal; + _emberMetalComputed.computed.gt = _emberMetalComputed_macros.gt; + _emberMetalComputed.computed.gte = _emberMetalComputed_macros.gte; + _emberMetalComputed.computed.lt = _emberMetalComputed_macros.lt; + _emberMetalComputed.computed.lte = _emberMetalComputed_macros.lte; + _emberMetalComputed.computed.alias = _emberMetalAlias.default; + _emberMetalComputed.computed.oneWay = _emberMetalComputed_macros.oneWay; + _emberMetalComputed.computed.reads = _emberMetalComputed_macros.oneWay; + _emberMetalComputed.computed.readOnly = _emberMetalComputed_macros.readOnly; + _emberMetalComputed.computed.defaultTo = _emberMetalComputed_macros.defaultTo; + _emberMetalComputed.computed.deprecatingAlias = _emberMetalComputed_macros.deprecatingAlias; + _emberMetalComputed.computed.and = _emberMetalComputed_macros.and; + _emberMetalComputed.computed.or = _emberMetalComputed_macros.or; + _emberMetalComputed.computed.any = _emberMetalComputed_macros.any; + + // END IMPORTS + + // BEGIN EXPORTS + var EmberInstrumentation = _emberMetalCore.default.Instrumentation = {}; + EmberInstrumentation.instrument = _emberMetalInstrumentation.instrument; + EmberInstrumentation.subscribe = _emberMetalInstrumentation.subscribe; + EmberInstrumentation.unsubscribe = _emberMetalInstrumentation.unsubscribe; + EmberInstrumentation.reset = _emberMetalInstrumentation.reset; + + _emberMetalCore.default.instrument = _emberMetalInstrumentation.instrument; + _emberMetalCore.default.subscribe = _emberMetalInstrumentation.subscribe; + + _emberMetalCore.default._Cache = _emberMetalCache.default; + + _emberMetalCore.default.generateGuid = _emberMetalUtils.generateGuid; + _emberMetalCore.default.GUID_KEY = _emberMetalUtils.GUID_KEY; + _emberMetalCore.default.platform = { + defineProperty: true, + hasPropertyAccessors: true + }; + + _emberMetalCore.default.Error = _emberMetalError.default; + _emberMetalCore.default.guidFor = _emberMetalUtils.guidFor; + _emberMetalCore.default.META_DESC = _emberMetalMeta.META_DESC; + _emberMetalCore.default.meta = _emberMetalMeta.meta; + _emberMetalCore.default.inspect = _emberMetalUtils.inspect; + + _emberMetalCore.default.tryCatchFinally = _emberMetalUtils.deprecatedTryCatchFinally; + _emberMetalCore.default.makeArray = _emberMetalUtils.makeArray; + _emberMetalCore.default.canInvoke = _emberMetalUtils.canInvoke; + _emberMetalCore.default.tryInvoke = _emberMetalUtils.tryInvoke; + _emberMetalCore.default.wrap = _emberMetalUtils.wrap; + _emberMetalCore.default.apply = _emberMetalUtils.apply; + _emberMetalCore.default.applyStr = _emberMetalUtils.applyStr; + _emberMetalCore.default.uuid = _emberMetalUtils.uuid; + + _emberMetalCore.default.Logger = _emberMetalLogger.default; + + _emberMetalCore.default.get = _emberMetalProperty_get.get; + _emberMetalCore.default.getWithDefault = _emberMetalProperty_get.getWithDefault; + _emberMetalCore.default.normalizeTuple = _emberMetalProperty_get.normalizeTuple; + _emberMetalCore.default._getPath = _emberMetalProperty_get._getPath; + + _emberMetalCore.default.on = _emberMetalEvents.on; + _emberMetalCore.default.addListener = _emberMetalEvents.addListener; + _emberMetalCore.default.removeListener = _emberMetalEvents.removeListener; + _emberMetalCore.default._suspendListener = _emberMetalEvents.suspendListener; + _emberMetalCore.default._suspendListeners = _emberMetalEvents.suspendListeners; + _emberMetalCore.default.sendEvent = _emberMetalEvents.sendEvent; + _emberMetalCore.default.hasListeners = _emberMetalEvents.hasListeners; + _emberMetalCore.default.watchedEvents = _emberMetalEvents.watchedEvents; + _emberMetalCore.default.listenersFor = _emberMetalEvents.listenersFor; + _emberMetalCore.default.accumulateListeners = _emberMetalEvents.accumulateListeners; + + _emberMetalCore.default._ObserverSet = _emberMetalObserver_set.default; + + _emberMetalCore.default.propertyWillChange = _emberMetalProperty_events.propertyWillChange; + _emberMetalCore.default.propertyDidChange = _emberMetalProperty_events.propertyDidChange; + _emberMetalCore.default.overrideChains = _emberMetalProperty_events.overrideChains; + _emberMetalCore.default.beginPropertyChanges = _emberMetalProperty_events.beginPropertyChanges; + _emberMetalCore.default.endPropertyChanges = _emberMetalProperty_events.endPropertyChanges; + _emberMetalCore.default.changeProperties = _emberMetalProperty_events.changeProperties; + + _emberMetalCore.default.defineProperty = _emberMetalProperties.defineProperty; + + _emberMetalCore.default.set = _emberMetalProperty_set.set; + _emberMetalCore.default.trySet = _emberMetalProperty_set.trySet; + + _emberMetalCore.default.OrderedSet = _emberMetalMap.OrderedSet; + _emberMetalCore.default.Map = _emberMetalMap.Map; + _emberMetalCore.default.MapWithDefault = _emberMetalMap.MapWithDefault; + + _emberMetalCore.default.getProperties = _emberMetalGet_properties.default; + _emberMetalCore.default.setProperties = _emberMetalSet_properties.default; + + _emberMetalCore.default.watchKey = _emberMetalWatch_key.watchKey; + _emberMetalCore.default.unwatchKey = _emberMetalWatch_key.unwatchKey; + + _emberMetalCore.default.flushPendingChains = _emberMetalChains.flushPendingChains; + _emberMetalCore.default.removeChainWatcher = _emberMetalChains.removeChainWatcher; + _emberMetalCore.default._ChainNode = _emberMetalChains.ChainNode; + _emberMetalCore.default.finishChains = _emberMetalChains.finishChains; + + _emberMetalCore.default.watchPath = _emberMetalWatch_path.watchPath; + _emberMetalCore.default.unwatchPath = _emberMetalWatch_path.unwatchPath; + + _emberMetalCore.default.watch = _emberMetalWatching.watch; + _emberMetalCore.default.isWatching = _emberMetalWatching.isWatching; + _emberMetalCore.default.unwatch = _emberMetalWatching.unwatch; + _emberMetalCore.default.rewatch = _emberMetalWatching.rewatch; + _emberMetalCore.default.destroy = _emberMetalWatching.destroy; + + _emberMetalCore.default.expandProperties = _emberMetalExpand_properties.default; + + _emberMetalCore.default.ComputedProperty = _emberMetalComputed.ComputedProperty; + _emberMetalCore.default.computed = _emberMetalComputed.computed; + _emberMetalCore.default.cacheFor = _emberMetalComputed.cacheFor; + + _emberMetalCore.default.addObserver = _emberMetalObserver.addObserver; + _emberMetalCore.default.observersFor = _emberMetalObserver.observersFor; + _emberMetalCore.default.removeObserver = _emberMetalObserver.removeObserver; + _emberMetalCore.default._suspendObserver = _emberMetalObserver._suspendObserver; + _emberMetalCore.default._suspendObservers = _emberMetalObserver._suspendObservers; + + _emberMetalCore.default.IS_BINDING = _emberMetalMixin.IS_BINDING; + _emberMetalCore.default.required = _emberMetalMixin.required; + _emberMetalCore.default.aliasMethod = _emberMetalMixin.aliasMethod; + _emberMetalCore.default.observer = _emberMetalMixin.observer; + _emberMetalCore.default.immediateObserver = _emberMetalMixin._immediateObserver; + _emberMetalCore.default.mixin = _emberMetalMixin.mixin; + _emberMetalCore.default.Mixin = _emberMetalMixin.Mixin; + + _emberMetalCore.default.bind = _emberMetalBinding.bind; + _emberMetalCore.default.Binding = _emberMetalBinding.Binding; + _emberMetalCore.default.isGlobalPath = _emberMetalBinding.isGlobalPath; + + _emberMetalCore.default.run = _emberMetalRun_loop.default; + + /** + @class Backburner + @for Ember + @private + */ + _emberMetalCore.default.Backburner = _backburner.default; + // this is the new go forward, once Ember Data updates to using `_Backburner` we + // can remove the non-underscored version. + _emberMetalCore.default._Backburner = _backburner.default; + + _emberMetalCore.default.libraries = new _emberMetalLibraries.default(); + _emberMetalCore.default.libraries.registerCoreLibrary('Ember', _emberMetalCore.default.VERSION); + + _emberMetalCore.default.isNone = _emberMetalIs_none.default; + _emberMetalCore.default.isEmpty = _emberMetalIs_empty.default; + _emberMetalCore.default.isBlank = _emberMetalIs_blank.default; + _emberMetalCore.default.isPresent = _emberMetalIs_present.default; + + _emberMetalCore.default.merge = _emberMetalMerge.default; + + _emberMetalCore.default.FEATURES = _emberMetalFeatures.FEATURES; + _emberMetalCore.default.FEATURES.isEnabled = _emberMetalFeatures.default; + + /** + A function may be assigned to `Ember.onerror` to be called when Ember + internals encounter an error. This is useful for specialized error handling + and reporting code. + + ```javascript + Ember.onerror = function(error) { + Em.$.ajax('/report-error', 'POST', { + stack: error.stack, + otherInformation: 'whatever app state you want to provide' + }); + }; + ``` + + Internally, `Ember.onerror` is used as Backburner's error handler. + + @event onerror + @for Ember + @param {Exception} error the error object + @public + */ + _emberMetalCore.default.onerror = null; + // END EXPORTS + + // do this for side-effects of updating Ember.assert, warn, etc when + // ember-debug is present + // This needs to be called before any deprecateFunc + if (_require.has('ember-debug')) { + _require.default('ember-debug'); + } else { + _emberMetalCore.default.Debug = {}; + + _emberMetalCore.default.Debug.registerDeprecationHandler = function () {}; + _emberMetalCore.default.Debug.registerWarnHandler = function () {}; + } + + _emberMetalCore.default.create = _emberMetalDebug.deprecateFunc('Ember.create is deprecated in favor of Object.create', { id: 'ember-metal.ember-create', until: '3.0.0' }, Object.create); + _emberMetalCore.default.keys = _emberMetalDebug.deprecateFunc('Ember.keys is deprecated in favor of Object.keys', { id: 'ember-metal.ember.keys', until: '3.0.0' }, Object.keys); + + exports.default = _emberMetalCore.default; +}); enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalComputed, _emberMetalAlias, _emberMetalProperties, _containerOwner) { 'use strict'; /** Read-only property that returns the result of a container lookup. @@ -17269,17 +17763,22 @@ ```javascript Ember.isPresent(); // false Ember.isPresent(null); // false Ember.isPresent(undefined); // false Ember.isPresent(''); // false - Ember.isPresent([]); // false - Ember.isPresent('\n\t'); // false Ember.isPresent(' '); // false + Ember.isPresent('\n\t'); // false + Ember.isPresent([]); // false + Ember.isPresent({ length: 0 }) // false + Ember.isPresent(false); // true + Ember.isPresent(true); // true + Ember.isPresent('string'); // true + Ember.isPresent(0); // true + Ember.isPresent(function() {}) // true Ember.isPresent({}); // true Ember.isPresent(false); // true Ember.isPresent('\n\t Hello'); // true - Ember.isPresent('Hello world'); // true Ember.isPresent([1,2,3]); // true ``` @method isPresent @for Ember @@ -19050,11 +19549,11 @@ }); //filters will be created as a separate array during the object's initialization App.Filterable = Ember.Mixin.create({ init: function() { - this._super.apply(this, arguments); + this._super(...arguments); this.set("filters", Ember.A()); } }); ``` @@ -19785,10 +20284,11 @@ 'use strict'; exports.Descriptor = Descriptor; exports.MANDATORY_SETTER_FUNCTION = MANDATORY_SETTER_FUNCTION; exports.DEFAULT_GETTER_FUNCTION = DEFAULT_GETTER_FUNCTION; + exports.INHERITING_GETTER_FUNCTION = INHERITING_GETTER_FUNCTION; exports.defineProperty = defineProperty; // .......................................................... // DESCRIPTOR // @@ -19803,27 +20303,56 @@ function Descriptor() { this.isDescriptor = true; } + var REDEFINE_SUPPORTED = (function () { + // https://github.com/spalger/kibana/commit/b7e35e6737df585585332857a4c397dc206e7ff9 + var a = Object.create(Object.prototype, { + prop: { + configurable: true, + value: 1 + } + }); + + Object.defineProperty(a, 'prop', { + configurable: true, + value: 2 + }); + + return a.prop === 2; + })(); // .......................................................... // DEFINING PROPERTIES API // function MANDATORY_SETTER_FUNCTION(name) { - return function SETTER_FUNCTION(value) { + function SETTER_FUNCTION(value) { _emberMetalDebug.assert('You must use Ember.set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false); - }; + } + + SETTER_FUNCTION.isMandatorySetter = true; + return SETTER_FUNCTION; } function DEFAULT_GETTER_FUNCTION(name) { return function GETTER_FUNCTION() { var meta = this['__ember_meta__']; return meta && meta.peekValues(name); }; } + function INHERITING_GETTER_FUNCTION(name) { + function IGETTER_FUNCTION() { + var proto = Object.getPrototypeOf(this); + return proto && proto[name]; + } + + IGETTER_FUNCTION.isInheritingGetter = true; + return IGETTER_FUNCTION; + } + /** NOTE: This is a low-level method used by other parts of the API. You almost never want to call this method directly. Instead you should use `Ember.mixin()` to define new properties. @@ -19905,16 +20434,23 @@ if (desc == null) { value = data; if (watching) { meta.writeValues(keyName, data); - Object.defineProperty(obj, keyName, { + + var defaultDescriptor = { configurable: true, enumerable: true, set: MANDATORY_SETTER_FUNCTION(keyName), get: DEFAULT_GETTER_FUNCTION(keyName) - }); + }; + + if (REDEFINE_SUPPORTED) { + Object.defineProperty(obj, keyName, defaultDescriptor); + } else { + handleBrokenPhantomDefineProperty(obj, keyName, defaultDescriptor); + } } else { obj[keyName] = data; } } else { value = desc; @@ -19936,10 +20472,16 @@ obj.didDefineProperty(obj, keyName, value); } return this; } + + function handleBrokenPhantomDefineProperty(obj, keyName, desc) { + // https://github.com/ariya/phantomjs/issues/11856 + Object.defineProperty(obj, keyName, { configurable: true, writable: true, value: 'iCry' }); + Object.defineProperty(obj, keyName, desc); + } }); enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/symbol'], function (exports, _emberMetalUtils, _emberMetalMeta, _emberMetalEvents, _emberMetalObserver_set, _emberMetalSymbol) { 'use strict'; var PROPERTY_DID_CHANGE = _emberMetalSymbol.default('PROPERTY_DID_CHANGE'); @@ -20220,11 +20762,11 @@ exports.overrideChains = overrideChains; exports.beginPropertyChanges = beginPropertyChanges; exports.endPropertyChanges = endPropertyChanges; exports.changeProperties = changeProperties; }); -enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/meta'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalPath_cache, _emberMetalMeta) { +enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/path_cache'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalError, _emberMetalPath_cache) { /** @module ember-metal */ 'use strict'; @@ -20278,11 +20820,10 @@ // Helpers that operate with 'this' within an #each if (keyName === '') { return obj; } - var meta = _emberMetalMeta.peekMeta(obj); var value = obj[keyName]; var desc = value !== null && typeof value === 'object' && value.isDescriptor ? value : undefined; var ret; if (desc === undefined && _emberMetalPath_cache.isPath(keyName)) { @@ -20290,15 +20831,11 @@ } if (desc) { return desc.get(obj, keyName); } else { - if (meta && meta.peekWatching(keyName) > 0) { - ret = meta.peekValues(keyName); - } else { - ret = value; - } + ret = value; if (ret === undefined && 'object' === typeof obj && !(keyName in obj) && 'function' === typeof obj.unknownProperty) { return obj.unknownProperty(keyName); } @@ -20405,11 +20942,11 @@ return value; } exports.default = get; }); -enifed('ember-metal/property_set', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/meta'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_events, _emberMetalProperties, _emberMetalError, _emberMetalPath_cache, _emberMetalMeta) { +enifed('ember-metal/property_set', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/meta', 'ember-metal/utils'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_events, _emberMetalProperties, _emberMetalError, _emberMetalPath_cache, _emberMetalMeta, _emberMetalUtils) { 'use strict'; exports.set = set; exports.trySet = trySet; @@ -20462,20 +20999,26 @@ // `setUnknownProperty` method exists on the object if (isUnknown && 'function' === typeof obj.setUnknownProperty) { obj.setUnknownProperty(keyName, value); } else if (meta && meta.peekWatching(keyName) > 0) { if (meta.proto !== obj) { - currentValue = meta.peekValues(keyName); + currentValue = obj[keyName]; } // only trigger a change if the value has changed if (value !== currentValue) { _emberMetalProperty_events.propertyWillChange(obj, keyName); if (currentValue === undefined && !(keyName in obj) || !Object.prototype.propertyIsEnumerable.call(obj, keyName)) { _emberMetalProperties.defineProperty(obj, keyName, null, value); // setup mandatory setter } else { - meta.writeValues(keyName, value); + var descriptor = _emberMetalUtils.lookupDescriptor(obj, keyName); + var isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter; + if (isMandatorySetter) { + meta.writeValues(keyName, value); + } else { + obj[keyName] = value; + } } _emberMetalProperty_events.propertyDidChange(obj, keyName); } } else { @@ -22333,10 +22876,11 @@ exports.tryInvoke = tryInvoke; exports.makeArray = makeArray; exports.inspect = inspect; exports.apply = apply; exports.applyStr = applyStr; + exports.lookupDescriptor = lookupDescriptor; var _uuid = 0; /** Generates a universally unique identifier. This method is used internally by Ember for assisting with @@ -22866,22 +23410,36 @@ default: return t[m].apply(t, a); } } + function lookupDescriptor(obj, keyName) { + var current = obj; + while (current) { + var descriptor = Object.getOwnPropertyDescriptor(current, keyName); + + if (descriptor) { + return descriptor; + } + + current = Object.getPrototypeOf(current); + } + + return null; + } + exports.GUID_KEY = GUID_KEY; exports.makeArray = makeArray; exports.canInvoke = canInvoke; }); -enifed('ember-metal/watch_key', ['exports', 'ember-metal/features', 'ember-metal/meta', 'ember-metal/properties'], function (exports, _emberMetalFeatures, _emberMetalMeta, _emberMetalProperties) { +enifed('ember-metal/watch_key', ['exports', 'ember-metal/features', 'ember-metal/meta', 'ember-metal/properties', 'ember-metal/utils'], function (exports, _emberMetalFeatures, _emberMetalMeta, _emberMetalProperties, _emberMetalUtils) { 'use strict'; exports.watchKey = watchKey; exports.unwatchKey = unwatchKey; - var handleMandatorySetter = undefined, - lookupDescriptor = undefined; + var handleMandatorySetter = undefined; function watchKey(obj, keyName, meta) { // can't watch length on Array - it is special... if (keyName === 'length' && Array.isArray(obj)) { return; @@ -22901,33 +23459,22 @@ if ('function' === typeof obj.willWatchProperty) { obj.willWatchProperty(keyName); } + // NOTE: this is dropped for prod + minified builds handleMandatorySetter(m, obj, keyName); } else { m.writeWatching(keyName, (m.peekWatching(keyName) || 0) + 1); } } - lookupDescriptor = function lookupDescriptor(obj, keyName) { - var current = obj; - while (current) { - var descriptor = Object.getOwnPropertyDescriptor(current, keyName); - - if (descriptor) { - return descriptor; - } - - current = Object.getPrototypeOf(current); - } - - return null; - }; - + // Future traveler, although this code looks scary. It merely exists in + // development to aid in development asertions. Production builds of + // ember strip this entire block out handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) { - var descriptor = lookupDescriptor(obj, keyName); + var descriptor = _emberMetalUtils.lookupDescriptor(obj, keyName); var configurable = descriptor ? descriptor.configurable : true; var isWritable = descriptor ? descriptor.writable : true; var hasValue = descriptor ? 'value' in descriptor : true; var possibleDesc = descriptor && descriptor.value; var isDescriptor = possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor; @@ -22936,17 +23483,25 @@ return; } // this x in Y deopts, so keeping it in this function is better; if (configurable && isWritable && hasValue && keyName in obj) { - m.writeValues(keyName, obj[keyName]); - Object.defineProperty(obj, keyName, { + var desc = { configurable: true, enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName), set: _emberMetalProperties.MANDATORY_SETTER_FUNCTION(keyName), - get: _emberMetalProperties.DEFAULT_GETTER_FUNCTION(keyName) - }); + get: undefined + }; + + if (Object.prototype.hasOwnProperty.call(obj, keyName)) { + m.writeValues(keyName, obj[keyName]); + desc.get = _emberMetalProperties.DEFAULT_GETTER_FUNCTION(keyName); + } else { + desc.get = _emberMetalProperties.INHERITING_GETTER_FUNCTION(keyName); + } + + Object.defineProperty(obj, keyName, desc); } }; function unwatchKey(obj, keyName, meta) { var m = meta || _emberMetalMeta.meta(obj); @@ -22954,34 +23509,43 @@ if (count === 1) { m.writeWatching(keyName, 0); var possibleDesc = obj[keyName]; var desc = possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor ? possibleDesc : undefined; + if (desc && desc.didUnwatch) { desc.didUnwatch(obj, keyName); } if ('function' === typeof obj.didUnwatchProperty) { obj.didUnwatchProperty(keyName); } + // It is true, the following code looks quite WAT. But have no fear, It + // exists purely to improve development ergonomics and is removed from + // ember.min.js and ember.prod.js builds. + // + // Some further context: Once a property is watched by ember, bypassing `set` + // for mutation, will bypass observation. This code exists to assert when + // that occurs, and attempt to provide more helpful feedback. The alternative + // is tricky to debug partially observable properties. if (!desc && keyName in obj) { - Object.defineProperty(obj, keyName, { - configurable: true, - enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName), - set: function (val) { - // redefine to set as enumerable + var maybeMandatoryDescriptor = _emberMetalUtils.lookupDescriptor(obj, keyName); + + if (maybeMandatoryDescriptor.set && maybeMandatoryDescriptor.set.isMandatorySetter) { + if (maybeMandatoryDescriptor.get && maybeMandatoryDescriptor.get.isInheritingGetter) { + delete obj[keyName]; + } else { Object.defineProperty(obj, keyName, { configurable: true, + enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName), writable: true, - enumerable: true, - value: val + value: m.peekValues(keyName) }); m.deleteFromValues(keyName); - }, - get: _emberMetalProperties.DEFAULT_GETTER_FUNCTION(keyName) - }); + } + } } } else if (count > 1) { m.writeWatching(keyName, count - 1); } } @@ -23142,10 +23706,15 @@ } } } } }); +enifed('ember-metal-views/index', ['exports', 'ember-metal-views/renderer'], function (exports, _emberMetalViewsRenderer) { + 'use strict'; + + exports.Renderer = _emberMetalViewsRenderer.default; +}); enifed('ember-metal-views/renderer', ['exports', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/assign', 'ember-metal/set_properties', 'ember-views/system/build-component-template', 'ember-metal/environment'], function (exports, _emberMetalRun_loop, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalAssign, _emberMetalSet_properties, _emberViewsSystemBuildComponentTemplate, _emberMetalEnvironment) { 'use strict'; exports.MorphSet = MorphSet; @@ -23422,227 +23991,10 @@ } }; // element destroyed so view.destroy shouldn't try to remove it removedFromDOM exports.default = Renderer; }); -enifed('ember-metal-views', ['exports', 'ember-metal-views/renderer'], function (exports, _emberMetalViewsRenderer) { - 'use strict'; - - exports.Renderer = _emberMetalViewsRenderer.default; -}); -enifed('ember-metal', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/assign', 'ember-metal/merge', 'ember-metal/instrumentation', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/error', 'ember-metal/cache', 'ember-metal/logger', 'ember-metal/property_get', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/property_set', 'ember-metal/map', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/watch_key', 'ember-metal/chains', 'ember-metal/watch_path', 'ember-metal/watching', 'ember-metal/expand_properties', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/computed_macros', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/run_loop', 'ember-metal/libraries', 'ember-metal/is_none', 'ember-metal/is_empty', 'ember-metal/is_blank', 'ember-metal/is_present', 'backburner'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalAssign, _emberMetalMerge, _emberMetalInstrumentation, _emberMetalUtils, _emberMetalMeta, _emberMetalError, _emberMetalCache, _emberMetalLogger, _emberMetalProperty_get, _emberMetalEvents, _emberMetalObserver_set, _emberMetalProperty_events, _emberMetalProperties, _emberMetalProperty_set, _emberMetalMap, _emberMetalGet_properties, _emberMetalSet_properties, _emberMetalWatch_key, _emberMetalChains, _emberMetalWatch_path, _emberMetalWatching, _emberMetalExpand_properties, _emberMetalComputed, _emberMetalAlias, _emberMetalComputed_macros, _emberMetalObserver, _emberMetalMixin, _emberMetalBinding, _emberMetalRun_loop, _emberMetalLibraries, _emberMetalIs_none, _emberMetalIs_empty, _emberMetalIs_blank, _emberMetalIs_present, _backburner) { - /** - @module ember - @submodule ember-metal - */ - - // BEGIN IMPORTS - 'use strict'; - - _emberMetalComputed.computed.empty = _emberMetalComputed_macros.empty; - _emberMetalComputed.computed.notEmpty = _emberMetalComputed_macros.notEmpty; - _emberMetalComputed.computed.none = _emberMetalComputed_macros.none; - _emberMetalComputed.computed.not = _emberMetalComputed_macros.not; - _emberMetalComputed.computed.bool = _emberMetalComputed_macros.bool; - _emberMetalComputed.computed.match = _emberMetalComputed_macros.match; - _emberMetalComputed.computed.equal = _emberMetalComputed_macros.equal; - _emberMetalComputed.computed.gt = _emberMetalComputed_macros.gt; - _emberMetalComputed.computed.gte = _emberMetalComputed_macros.gte; - _emberMetalComputed.computed.lt = _emberMetalComputed_macros.lt; - _emberMetalComputed.computed.lte = _emberMetalComputed_macros.lte; - _emberMetalComputed.computed.alias = _emberMetalAlias.default; - _emberMetalComputed.computed.oneWay = _emberMetalComputed_macros.oneWay; - _emberMetalComputed.computed.reads = _emberMetalComputed_macros.oneWay; - _emberMetalComputed.computed.readOnly = _emberMetalComputed_macros.readOnly; - _emberMetalComputed.computed.defaultTo = _emberMetalComputed_macros.defaultTo; - _emberMetalComputed.computed.deprecatingAlias = _emberMetalComputed_macros.deprecatingAlias; - _emberMetalComputed.computed.and = _emberMetalComputed_macros.and; - _emberMetalComputed.computed.or = _emberMetalComputed_macros.or; - _emberMetalComputed.computed.any = _emberMetalComputed_macros.any; - - // END IMPORTS - - // BEGIN EXPORTS - var EmberInstrumentation = _emberMetalCore.default.Instrumentation = {}; - EmberInstrumentation.instrument = _emberMetalInstrumentation.instrument; - EmberInstrumentation.subscribe = _emberMetalInstrumentation.subscribe; - EmberInstrumentation.unsubscribe = _emberMetalInstrumentation.unsubscribe; - EmberInstrumentation.reset = _emberMetalInstrumentation.reset; - - _emberMetalCore.default.instrument = _emberMetalInstrumentation.instrument; - _emberMetalCore.default.subscribe = _emberMetalInstrumentation.subscribe; - - _emberMetalCore.default._Cache = _emberMetalCache.default; - - _emberMetalCore.default.generateGuid = _emberMetalUtils.generateGuid; - _emberMetalCore.default.GUID_KEY = _emberMetalUtils.GUID_KEY; - _emberMetalCore.default.platform = { - defineProperty: true, - hasPropertyAccessors: true - }; - - _emberMetalCore.default.Error = _emberMetalError.default; - _emberMetalCore.default.guidFor = _emberMetalUtils.guidFor; - _emberMetalCore.default.META_DESC = _emberMetalMeta.META_DESC; - _emberMetalCore.default.meta = _emberMetalMeta.meta; - _emberMetalCore.default.inspect = _emberMetalUtils.inspect; - - _emberMetalCore.default.tryCatchFinally = _emberMetalUtils.deprecatedTryCatchFinally; - _emberMetalCore.default.makeArray = _emberMetalUtils.makeArray; - _emberMetalCore.default.canInvoke = _emberMetalUtils.canInvoke; - _emberMetalCore.default.tryInvoke = _emberMetalUtils.tryInvoke; - _emberMetalCore.default.wrap = _emberMetalUtils.wrap; - _emberMetalCore.default.apply = _emberMetalUtils.apply; - _emberMetalCore.default.applyStr = _emberMetalUtils.applyStr; - _emberMetalCore.default.uuid = _emberMetalUtils.uuid; - - _emberMetalCore.default.Logger = _emberMetalLogger.default; - - _emberMetalCore.default.get = _emberMetalProperty_get.get; - _emberMetalCore.default.getWithDefault = _emberMetalProperty_get.getWithDefault; - _emberMetalCore.default.normalizeTuple = _emberMetalProperty_get.normalizeTuple; - _emberMetalCore.default._getPath = _emberMetalProperty_get._getPath; - - _emberMetalCore.default.on = _emberMetalEvents.on; - _emberMetalCore.default.addListener = _emberMetalEvents.addListener; - _emberMetalCore.default.removeListener = _emberMetalEvents.removeListener; - _emberMetalCore.default._suspendListener = _emberMetalEvents.suspendListener; - _emberMetalCore.default._suspendListeners = _emberMetalEvents.suspendListeners; - _emberMetalCore.default.sendEvent = _emberMetalEvents.sendEvent; - _emberMetalCore.default.hasListeners = _emberMetalEvents.hasListeners; - _emberMetalCore.default.watchedEvents = _emberMetalEvents.watchedEvents; - _emberMetalCore.default.listenersFor = _emberMetalEvents.listenersFor; - _emberMetalCore.default.accumulateListeners = _emberMetalEvents.accumulateListeners; - - _emberMetalCore.default._ObserverSet = _emberMetalObserver_set.default; - - _emberMetalCore.default.propertyWillChange = _emberMetalProperty_events.propertyWillChange; - _emberMetalCore.default.propertyDidChange = _emberMetalProperty_events.propertyDidChange; - _emberMetalCore.default.overrideChains = _emberMetalProperty_events.overrideChains; - _emberMetalCore.default.beginPropertyChanges = _emberMetalProperty_events.beginPropertyChanges; - _emberMetalCore.default.endPropertyChanges = _emberMetalProperty_events.endPropertyChanges; - _emberMetalCore.default.changeProperties = _emberMetalProperty_events.changeProperties; - - _emberMetalCore.default.defineProperty = _emberMetalProperties.defineProperty; - - _emberMetalCore.default.set = _emberMetalProperty_set.set; - _emberMetalCore.default.trySet = _emberMetalProperty_set.trySet; - - _emberMetalCore.default.OrderedSet = _emberMetalMap.OrderedSet; - _emberMetalCore.default.Map = _emberMetalMap.Map; - _emberMetalCore.default.MapWithDefault = _emberMetalMap.MapWithDefault; - - _emberMetalCore.default.getProperties = _emberMetalGet_properties.default; - _emberMetalCore.default.setProperties = _emberMetalSet_properties.default; - - _emberMetalCore.default.watchKey = _emberMetalWatch_key.watchKey; - _emberMetalCore.default.unwatchKey = _emberMetalWatch_key.unwatchKey; - - _emberMetalCore.default.flushPendingChains = _emberMetalChains.flushPendingChains; - _emberMetalCore.default.removeChainWatcher = _emberMetalChains.removeChainWatcher; - _emberMetalCore.default._ChainNode = _emberMetalChains.ChainNode; - _emberMetalCore.default.finishChains = _emberMetalChains.finishChains; - - _emberMetalCore.default.watchPath = _emberMetalWatch_path.watchPath; - _emberMetalCore.default.unwatchPath = _emberMetalWatch_path.unwatchPath; - - _emberMetalCore.default.watch = _emberMetalWatching.watch; - _emberMetalCore.default.isWatching = _emberMetalWatching.isWatching; - _emberMetalCore.default.unwatch = _emberMetalWatching.unwatch; - _emberMetalCore.default.rewatch = _emberMetalWatching.rewatch; - _emberMetalCore.default.destroy = _emberMetalWatching.destroy; - - _emberMetalCore.default.expandProperties = _emberMetalExpand_properties.default; - - _emberMetalCore.default.ComputedProperty = _emberMetalComputed.ComputedProperty; - _emberMetalCore.default.computed = _emberMetalComputed.computed; - _emberMetalCore.default.cacheFor = _emberMetalComputed.cacheFor; - - _emberMetalCore.default.addObserver = _emberMetalObserver.addObserver; - _emberMetalCore.default.observersFor = _emberMetalObserver.observersFor; - _emberMetalCore.default.removeObserver = _emberMetalObserver.removeObserver; - _emberMetalCore.default._suspendObserver = _emberMetalObserver._suspendObserver; - _emberMetalCore.default._suspendObservers = _emberMetalObserver._suspendObservers; - - _emberMetalCore.default.IS_BINDING = _emberMetalMixin.IS_BINDING; - _emberMetalCore.default.required = _emberMetalMixin.required; - _emberMetalCore.default.aliasMethod = _emberMetalMixin.aliasMethod; - _emberMetalCore.default.observer = _emberMetalMixin.observer; - _emberMetalCore.default.immediateObserver = _emberMetalMixin._immediateObserver; - _emberMetalCore.default.mixin = _emberMetalMixin.mixin; - _emberMetalCore.default.Mixin = _emberMetalMixin.Mixin; - - _emberMetalCore.default.bind = _emberMetalBinding.bind; - _emberMetalCore.default.Binding = _emberMetalBinding.Binding; - _emberMetalCore.default.isGlobalPath = _emberMetalBinding.isGlobalPath; - - _emberMetalCore.default.run = _emberMetalRun_loop.default; - - /** - @class Backburner - @for Ember - @private - */ - _emberMetalCore.default.Backburner = _backburner.default; - // this is the new go forward, once Ember Data updates to using `_Backburner` we - // can remove the non-underscored version. - _emberMetalCore.default._Backburner = _backburner.default; - - _emberMetalCore.default.libraries = new _emberMetalLibraries.default(); - _emberMetalCore.default.libraries.registerCoreLibrary('Ember', _emberMetalCore.default.VERSION); - - _emberMetalCore.default.isNone = _emberMetalIs_none.default; - _emberMetalCore.default.isEmpty = _emberMetalIs_empty.default; - _emberMetalCore.default.isBlank = _emberMetalIs_blank.default; - _emberMetalCore.default.isPresent = _emberMetalIs_present.default; - - _emberMetalCore.default.merge = _emberMetalMerge.default; - - _emberMetalCore.default.FEATURES = _emberMetalFeatures.FEATURES; - _emberMetalCore.default.FEATURES.isEnabled = _emberMetalFeatures.default; - - /** - A function may be assigned to `Ember.onerror` to be called when Ember - internals encounter an error. This is useful for specialized error handling - and reporting code. - - ```javascript - Ember.onerror = function(error) { - Em.$.ajax('/report-error', 'POST', { - stack: error.stack, - otherInformation: 'whatever app state you want to provide' - }); - }; - ``` - - Internally, `Ember.onerror` is used as Backburner's error handler. - - @event onerror - @for Ember - @param {Exception} error the error object - @public - */ - _emberMetalCore.default.onerror = null; - // END EXPORTS - - // do this for side-effects of updating Ember.assert, warn, etc when - // ember-debug is present - // This needs to be called before any deprecateFunc - if (_emberMetalCore.default.__loader.registry['ember-debug']) { - requireModule('ember-debug'); - } else { - _emberMetalCore.default.Debug = {}; - - _emberMetalCore.default.Debug.registerDeprecationHandler = function () {}; - _emberMetalCore.default.Debug.registerWarnHandler = function () {}; - } - - _emberMetalCore.default.create = _emberMetalDebug.deprecateFunc('Ember.create is deprecated in favor of Object.create', { id: 'ember-metal.ember-create', until: '3.0.0' }, Object.create); - _emberMetalCore.default.keys = _emberMetalDebug.deprecateFunc('Ember.keys is deprecated in favor of Object.keys', { id: 'ember-metal.ember.keys', until: '3.0.0' }, Object.keys); - - exports.default = _emberMetalCore.default; -}); enifed('ember-routing/ext/controller', ['exports', 'ember-metal/property_get', 'ember-runtime/mixins/controller'], function (exports, _emberMetalProperty_get, _emberRuntimeMixinsController) { 'use strict'; /** @module ember @@ -23811,10 +24163,35 @@ // resolve), which is used in router transitions to prevent unnecessary // loading state entry if all context promises resolve on the // 'actions' queue first. _emberMetalRun_loop.default._addQueue('routerTransitions', 'actions'); }); +enifed('ember-routing/index', ['exports', 'ember-metal/core', 'ember-routing/ext/run_loop', 'ember-routing/ext/controller', 'ember-routing/location/api', 'ember-routing/location/none_location', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/system/generate_controller', 'ember-routing/system/controller_for', 'ember-routing/system/dsl', 'ember-routing/system/router', 'ember-routing/system/route'], function (exports, _emberMetalCore, _emberRoutingExtRun_loop, _emberRoutingExtController, _emberRoutingLocationApi, _emberRoutingLocationNone_location, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingSystemGenerate_controller, _emberRoutingSystemController_for, _emberRoutingSystemDsl, _emberRoutingSystemRouter, _emberRoutingSystemRoute) { + /** + @module ember + @submodule ember-routing + */ + + 'use strict'; + + _emberMetalCore.default.Location = _emberRoutingLocationApi.default; + _emberMetalCore.default.AutoLocation = _emberRoutingLocationAuto_location.default; + _emberMetalCore.default.HashLocation = _emberRoutingLocationHash_location.default; + _emberMetalCore.default.HistoryLocation = _emberRoutingLocationHistory_location.default; + _emberMetalCore.default.NoneLocation = _emberRoutingLocationNone_location.default; + + _emberMetalCore.default.controllerFor = _emberRoutingSystemController_for.default; + _emberMetalCore.default.generateControllerFactory = _emberRoutingSystemGenerate_controller.generateControllerFactory; + _emberMetalCore.default.generateController = _emberRoutingSystemGenerate_controller.default; + _emberMetalCore.default.RouterDSL = _emberRoutingSystemDsl.default; + _emberMetalCore.default.Router = _emberRoutingSystemRouter.default; + _emberMetalCore.default.Route = _emberRoutingSystemRoute.default; + + exports.default = _emberMetalCore.default; +}); + +// ES6TODO: Cleanup modules with side-effects below enifed('ember-routing/location/api', ['exports', 'ember-metal/debug', 'ember-metal/environment', 'ember-routing/location/util'], function (exports, _emberMetalDebug, _emberMetalEnvironment, _emberRoutingLocationUtil) { 'use strict'; /** @module ember @@ -24998,11 +25375,14 @@ function DSL(name, options) { this.parent = name; this.enableLoadingSubstates = options && options.enableLoadingSubstates; this.matches = []; + this.explicitIndex = undefined; + this.options = options; } + exports.default = DSL; DSL.prototype = { route: function (name, options, callback) { var dummyErrorRoute = '/_unused_dummy_error_path_route_' + name + '/:error'; @@ -25030,13 +25410,11 @@ createRoute(this, name + '_error', { path: dummyErrorRoute }); } if (callback) { var fullName = getFullName(this, name, options.resetNamespace); - var dsl = new DSL(fullName, { - enableLoadingSubstates: this.enableLoadingSubstates - }); + var dsl = new DSL(fullName, this.options); createRoute(dsl, 'loading'); createRoute(dsl, 'error', { path: dummyErrorRoute }); callback.call(dsl); @@ -26435,11 +26813,11 @@ ```javascript App.Router.map(function() { this.route('post', { path: '/posts/:post_id' }); }); ``` - The model for the `post` route is `store.find('post', params.post_id)`. + The model for the `post` route is `store.findRecord('post', params.post_id)`. By default, if your route has a dynamic segment ending in `_id`: * The model class is determined from the segment (`post_id`'s class is `App.Post`) * The find method is called on the model class with the value of the dynamic segment. @@ -26453,28 +26831,28 @@ Routes without dynamic segments will always execute the model hook. ```javascript // no dynamic segment, model hook always called this.transitionTo('posts'); // model passed in, so model hook not called - thePost = store.find('post', 1); + thePost = store.findRecord('post', 1); this.transitionTo('post', thePost); // integer passed in, model hook is called this.transitionTo('post', 1); // model id passed in, model hook is called // useful for forcing the hook to execute - thePost = store.find('post', 1); + thePost = store.findRecord('post', 1); this.transitionTo('post', thePost.id); ``` This hook follows the asynchronous/promise semantics described in the documentation for `beforeModel`. In particular, if a promise returned from `model` fails, the error will be handled by the `error` hook on `Ember.Route`. Example ```javascript App.PostRoute = Ember.Route.extend({ model: function(params) { - return this.store.find('post', params.post_id); + return this.store.findRecord('post', params.post_id); } }); ``` @method model @param {Object} params the parameters extracted from the URL @@ -26637,11 +27015,11 @@ when implementing your `setupController` function, make sure to call `_super`: ```javascript App.PhotosRoute = Ember.Route.extend({ model: function() { - return this.store.find('photo'); + return this.store.findAll('photo'); }, setupController: function(controller, model) { // Call _super for default behavior this._super(controller, model); // Implement your custom setup after @@ -26964,11 +27342,11 @@ this.disconnectOutlet('modal'); } ``` @method disconnectOutlet @param {Object|String} options the options hash or outlet name - @private + @public */ disconnectOutlet: function (options) { var outletName; var parentView; if (!options || typeof options === 'string') { @@ -27066,10 +27444,11 @@ var ViewClass; var template; var LOG_VIEW_LOOKUPS = _emberMetalProperty_get.get(route.router, 'namespace.LOG_VIEW_LOOKUPS'); var into = options && options.into && options.into.replace(/\//g, '.'); var outlet = options && options.outlet || 'main'; + var owner = _containerOwner.getOwner(route); if (name) { name = name.replace(/\//g, '.'); templateName = name; } else { @@ -27077,19 +27456,19 @@ templateName = route.templateName || name; } if (!controller) { if (namePassed) { - controller = _containerOwner.getOwner(route).lookup('controller:' + name) || route.controllerName || route.routeName; + controller = owner.lookup('controller:' + name) || route.controllerName || route.routeName; } else { - controller = route.controllerName || _containerOwner.getOwner(route).lookup('controller:' + name); + controller = route.controllerName || owner.lookup('controller:' + name); } } if (typeof controller === 'string') { var controllerName = controller; - controller = _containerOwner.getOwner(route).lookup('controller:' + controllerName); + controller = owner.lookup('controller:' + controllerName); if (!controller) { throw new _emberMetalError.default('You passed `controller: \'' + controllerName + '\'` into the `render` method, but no such controller could be found.'); } } @@ -27099,21 +27478,21 @@ if (options && options.model) { controller.set('model', options.model); } - var owner = _containerOwner.getOwner(route); viewName = options && options.view || namePassed && name || route.viewName || name; ViewClass = owner._lookupFactory('view:' + viewName); template = owner.lookup('template:' + templateName); var parent; if (into && (parent = parentRoute(route)) && into === parentRoute(route).routeName) { into = undefined; } var renderOptions = { + owner: owner, into: into, outlet: outlet, name: name, controller: controller, ViewClass: ViewClass, @@ -27246,10 +27625,12 @@ // detect that property was not defined on controller enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/properties', 'ember-metal/empty_object', 'ember-metal/computed', 'ember-metal/assign', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-routing/system/dsl', 'ember-routing/location/api', 'ember-routing/utils', 'ember-metal/utils', 'ember-routing/system/router_state', 'container/owner', 'ember-metal/dictionary', 'router', 'router/transition'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberMetalError, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalProperties, _emberMetalEmpty_object, _emberMetalComputed, _emberMetalAssign, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented, _emberRoutingSystemDsl, _emberRoutingLocationApi, _emberRoutingUtils, _emberMetalUtils, _emberRoutingSystemRouter_state, _containerOwner, _emberMetalDictionary, _router4, _routerTransition) { 'use strict'; + exports.triggerEvent = triggerEvent; + function K() { return this; } var slice = [].slice; @@ -27288,40 +27669,44 @@ @default '/' @public */ rootURL: '/', - _initRouterJs: function (moduleBasedResolver) { + _initRouterJs: function () { var router = this.router = new _router4.default(); router.triggerEvent = triggerEvent; router._triggerWillChangeContext = K; router._triggerWillLeave = K; var dslCallbacks = this.constructor.dslCallbacks || [K]; - var dsl = new _emberRoutingSystemDsl.default(null, { - enableLoadingSubstates: !!moduleBasedResolver + var dsl = this._buildDSL(); + + dsl.route('application', { path: '/', resetNamespace: true, overrideNameAssertion: true }, function () { + for (var i = 0; i < dslCallbacks.length; i++) { + dslCallbacks[i].call(this); + } }); - function generateDSL() { - this.route('application', { path: '/', resetNamespace: true, overrideNameAssertion: true }, function () { - for (var i = 0; i < dslCallbacks.length; i++) { - dslCallbacks[i].call(this); - } - }); - } - - generateDSL.call(dsl); - if (_emberMetalProperty_get.get(this, 'namespace.LOG_TRANSITIONS_INTERNAL')) { router.log = _emberMetalLogger.default.debug; } router.map(dsl.generate()); }, + _buildDSL: function () { + var moduleBasedResolver = this._hasModuleBasedResolver(); + + return new _emberRoutingSystemDsl.default(null, { + enableLoadingSubstates: !!moduleBasedResolver + }); + }, + init: function () { + this._super.apply(this, arguments); + this._activeViews = {}; this._qpCache = new _emberMetalEmpty_object.default(); this._resetQueuedQueryParameterChanges(); this._handledErrors = _emberMetalDictionary.default(null); }, @@ -27343,36 +27728,52 @@ */ url: _emberMetalComputed.computed(function () { return _emberMetalProperty_get.get(this, 'location').getURL(); }), + _hasModuleBasedResolver: function () { + var owner = _containerOwner.getOwner(this); + + if (!owner) { + return false; + } + + var resolver = owner.application && owner.application.__registry__ && owner.application.__registry__.resolver; + + if (!resolver) { + return false; + } + + return !!resolver.moduleBasedResolver; + }, + /** Initializes the current router instance and sets up the change handling event listeners used by the instances `location` implementation. A property named `initialURL` will be used to determine the initial URL. If no value is found `/` will be used. @method startRouting @private */ - startRouting: function (moduleBasedResolver) { + startRouting: function () { var initialURL = _emberMetalProperty_get.get(this, 'initialURL'); - if (this.setupRouter(moduleBasedResolver)) { + if (this.setupRouter()) { if (typeof initialURL === 'undefined') { initialURL = _emberMetalProperty_get.get(this, 'location').getURL(); } var initialTransition = this.handleURL(initialURL); if (initialTransition && initialTransition.error) { throw initialTransition.error; } } }, - setupRouter: function (moduleBasedResolver) { + setupRouter: function () { var _this = this; - this._initRouterJs(moduleBasedResolver); + this._initRouterJs(); this._setupLocation(); var router = this.router; var location = _emberMetalProperty_get.get(this, 'location'); @@ -28650,10 +29051,26 @@ return _emberRoutingSystemQuery_params.default.create({ values: hash }); } }); +enifed('ember-routing-htmlbars/index', ['exports', 'ember-metal/core', 'ember-htmlbars/helpers', 'ember-htmlbars/keywords', 'ember-routing-htmlbars/helpers/query-params', 'ember-routing-htmlbars/keywords/action', 'ember-routing-htmlbars/keywords/element-action', 'ember-routing-htmlbars/keywords/render'], function (exports, _emberMetalCore, _emberHtmlbarsHelpers, _emberHtmlbarsKeywords, _emberRoutingHtmlbarsHelpersQueryParams, _emberRoutingHtmlbarsKeywordsAction, _emberRoutingHtmlbarsKeywordsElementAction, _emberRoutingHtmlbarsKeywordsRender) { + /** + @module ember + @submodule ember-routing-htmlbars + */ + + 'use strict'; + + _emberHtmlbarsHelpers.registerHelper('query-params', _emberRoutingHtmlbarsHelpersQueryParams.queryParamsHelper); + + _emberHtmlbarsKeywords.registerKeyword('action', _emberRoutingHtmlbarsKeywordsAction.default); + _emberHtmlbarsKeywords.registerKeyword('@element_action', _emberRoutingHtmlbarsKeywordsElementAction.default); + _emberHtmlbarsKeywords.registerKeyword('render', _emberRoutingHtmlbarsKeywordsRender.default); + + exports.default = _emberMetalCore.default; +}); enifed('ember-routing-htmlbars/keywords/action', ['exports', 'htmlbars-runtime/hooks', 'ember-routing-htmlbars/keywords/closure-action'], function (exports, _htmlbarsRuntimeHooks, _emberRoutingHtmlbarsKeywordsClosureAction) { /** @module ember @submodule ember-templates */ @@ -28834,11 +29251,11 @@ By default the `{{action}}` helper registers for DOM `click` events. You can supply an `on` option to the helper to specify a different DOM event name: ```handlebars - <div {{action "anActionName" on="double-click"}}> + <div {{action "anActionName" on="doubleClick"}}> click me </div> ``` See [Event Names](/api/classes/Ember.View.html#toc_event-names) for a list of @@ -29432,26 +29849,10 @@ } } return true; } }); -enifed('ember-routing-htmlbars', ['exports', 'ember-metal/core', 'ember-htmlbars/helpers', 'ember-htmlbars/keywords', 'ember-routing-htmlbars/helpers/query-params', 'ember-routing-htmlbars/keywords/action', 'ember-routing-htmlbars/keywords/element-action', 'ember-routing-htmlbars/keywords/render'], function (exports, _emberMetalCore, _emberHtmlbarsHelpers, _emberHtmlbarsKeywords, _emberRoutingHtmlbarsHelpersQueryParams, _emberRoutingHtmlbarsKeywordsAction, _emberRoutingHtmlbarsKeywordsElementAction, _emberRoutingHtmlbarsKeywordsRender) { - /** - @module ember - @submodule ember-routing-htmlbars - */ - - 'use strict'; - - _emberHtmlbarsHelpers.registerHelper('query-params', _emberRoutingHtmlbarsHelpersQueryParams.queryParamsHelper); - - _emberHtmlbarsKeywords.registerKeyword('action', _emberRoutingHtmlbarsKeywordsAction.default); - _emberHtmlbarsKeywords.registerKeyword('@element_action', _emberRoutingHtmlbarsKeywordsElementAction.default); - _emberHtmlbarsKeywords.registerKeyword('render', _emberRoutingHtmlbarsKeywordsRender.default); - - exports.default = _emberMetalCore.default; -}); enifed('ember-routing-views/components/link-to', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/computed_macros', 'ember-views/system/utils', 'ember-views/components/component', 'ember-runtime/inject', 'ember-runtime/system/service', 'ember-runtime/mixins/controller', 'ember-htmlbars/node-managers/component-node-manager', 'ember-htmlbars/templates/link-to'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberMetalProperty_get, _emberMetalComputed, _emberMetalComputed_macros, _emberViewsSystemUtils, _emberViewsComponentsComponent, _emberRuntimeInject, _emberRuntimeSystemService, _emberRuntimeMixinsController, _emberHtmlbarsNodeManagersComponentNodeManager, _emberHtmlbarsTemplatesLinkTo) { /** @module ember @submodule ember-templates */ @@ -29591,12 +29992,11 @@ "Overriding Application-wide Defaults". ### Keeping a link active for other routes If you need a link to be 'active' even when it doesn't match - the current route, you can use the the `current-when` - argument. + the current route, you can use the `current-when` argument. ```handlebars {{#link-to 'photoGallery' current-when='photos'}} Photo Gallery {{/link-to}} @@ -29623,11 +30023,11 @@ An optional model argument can be used for routes whose paths contain dynamic segments. This argument will become the model context of the linked route: ```javascript - App.Router.map(function() { + Router.map(function() { this.route("photoGallery", {path: "hamster-photos/:photo_id"}); }); ``` ```handlebars @@ -29648,11 +30048,11 @@ As the router transitions through the route path, each supplied model argument will become the context for the route with the dynamic segments: ```javascript - App.Router.map(function() { + Router.map(function() { this.route("photoGallery", { path: "hamster-photos/:photo_id" }, function() { this.route("comment", {path: "comments/:comment_id"}); }); }); ``` @@ -29675,11 +30075,11 @@ an optional string or integer argument can be passed for routes whose paths contain dynamic segments. This argument will become the value of the dynamic segment: ```javascript - App.Router.map(function() { + Router.map(function() { this.route("photoGallery", { path: "hamster-photos/:photo_id" }); }); ``` ```handlebars @@ -29765,11 +30165,11 @@ @submodule ember-routing-views */ 'use strict'; - _emberHtmlbarsTemplatesLinkTo.default.meta.revision = 'Ember@2.3.2'; + _emberHtmlbarsTemplatesLinkTo.default.meta.revision = 'Ember@2.4.0-beta.2'; /** `Ember.LinkComponent` renders an element whose `click` event triggers a transition of the application's instance of `Ember.Router` to a supplied route by name. @@ -29891,11 +30291,11 @@ /** By default the `{{link-to}}` component will bind to the `active`, `loading`, and `disabled` classes. It is discouraged to override these directly. @property classNameBindings @type Array - @default ['active', 'loading', 'disabled'] + @default ['active', 'loading', 'disabled', 'ember-transitioning-in', 'ember-transitioning-out'] @public */ classNameBindings: ['active', 'loading', 'disabled', 'transitioningIn', 'transitioningOut'], /** @@ -29927,17 +30327,17 @@ An overridable method called when `LinkComponent` objects are instantiated. Example: ```javascript App.MyLinkComponent = Ember.LinkComponent.extend({ init: function() { - this._super.apply(this, arguments); + this._super(...arguments); Ember.Logger.log('Event is ' + this.get('eventName')); } }); ``` NOTE: If you do override `init` for a framework class like `Ember.View`, - be sure to call `this._super.apply(this, arguments)` in your + be sure to call `this._super(...arguments)` in your `init` declaration! If you don't, Ember may not have an opportunity to do important setup work, and you'll see strange behavior in your application. @method init @private @@ -30247,19 +30647,32 @@ }); exports.default = LinkComponent; }); // creates inject.service +enifed('ember-routing-views/index', ['exports', 'ember-metal/core', 'ember-routing-views/components/link-to', 'ember-routing-views/views/outlet'], function (exports, _emberMetalCore, _emberRoutingViewsComponentsLinkTo, _emberRoutingViewsViewsOutlet) { + /** + @module ember + @submodule ember-routing-views + */ + + 'use strict'; + + _emberMetalCore.default.LinkComponent = _emberRoutingViewsComponentsLinkTo.default; + _emberMetalCore.default.OutletView = _emberRoutingViewsViewsOutlet.OutletView; + + exports.default = _emberMetalCore.default; +}); enifed('ember-routing-views/views/outlet', ['exports', 'ember-views/views/view', 'ember-htmlbars/templates/top-level-view'], function (exports, _emberViewsViewsView, _emberHtmlbarsTemplatesTopLevelView) { /** @module ember @submodule ember-routing-views */ 'use strict'; - _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.3.2'; + _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.4.0-beta.2'; var CoreOutletView = _emberViewsViewsView.default.extend({ defaultTemplate: _emberHtmlbarsTemplatesTopLevelView.default, init: function () { @@ -30292,48 +30705,10 @@ exports.CoreOutletView = CoreOutletView; var OutletView = CoreOutletView.extend({ tagName: '' }); exports.OutletView = OutletView; }); -enifed('ember-routing-views', ['exports', 'ember-metal/core', 'ember-routing-views/components/link-to', 'ember-routing-views/views/outlet'], function (exports, _emberMetalCore, _emberRoutingViewsComponentsLinkTo, _emberRoutingViewsViewsOutlet) { - /** - @module ember - @submodule ember-routing-views - */ - - 'use strict'; - - _emberMetalCore.default.LinkComponent = _emberRoutingViewsComponentsLinkTo.default; - _emberMetalCore.default.OutletView = _emberRoutingViewsViewsOutlet.OutletView; - - exports.default = _emberMetalCore.default; -}); -enifed('ember-routing', ['exports', 'ember-metal/core', 'ember-routing/ext/run_loop', 'ember-routing/ext/controller', 'ember-routing/location/api', 'ember-routing/location/none_location', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/system/generate_controller', 'ember-routing/system/controller_for', 'ember-routing/system/dsl', 'ember-routing/system/router', 'ember-routing/system/route'], function (exports, _emberMetalCore, _emberRoutingExtRun_loop, _emberRoutingExtController, _emberRoutingLocationApi, _emberRoutingLocationNone_location, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingSystemGenerate_controller, _emberRoutingSystemController_for, _emberRoutingSystemDsl, _emberRoutingSystemRouter, _emberRoutingSystemRoute) { - /** - @module ember - @submodule ember-routing - */ - - 'use strict'; - - _emberMetalCore.default.Location = _emberRoutingLocationApi.default; - _emberMetalCore.default.AutoLocation = _emberRoutingLocationAuto_location.default; - _emberMetalCore.default.HashLocation = _emberRoutingLocationHash_location.default; - _emberMetalCore.default.HistoryLocation = _emberRoutingLocationHistory_location.default; - _emberMetalCore.default.NoneLocation = _emberRoutingLocationNone_location.default; - - _emberMetalCore.default.controllerFor = _emberRoutingSystemController_for.default; - _emberMetalCore.default.generateControllerFactory = _emberRoutingSystemGenerate_controller.generateControllerFactory; - _emberMetalCore.default.generateController = _emberRoutingSystemGenerate_controller.default; - _emberMetalCore.default.RouterDSL = _emberRoutingSystemDsl.default; - _emberMetalCore.default.Router = _emberRoutingSystemRouter.default; - _emberMetalCore.default.Route = _emberRoutingSystemRoute.default; - - exports.default = _emberMetalCore.default; -}); - -// ES6TODO: Cleanup modules with side-effects below enifed('ember-runtime/compare', ['exports', 'ember-runtime/utils', 'ember-runtime/mixins/comparable'], function (exports, _emberRuntimeUtils, _emberRuntimeMixinsComparable) { 'use strict'; exports.default = compare; @@ -30352,32 +30727,63 @@ }; // // the spaceship operator // + // `. ___ + // __,' __`. _..----....____ + // __...--.'``;. ,. ;``--..__ .' ,-._ _.-' + // _..-''-------' `' `' `' O ``-''._ (,;') _,' + // ,'________________ \`-._`-',' + // `._ ```````````------...___ '-.._'-: + // ```--.._ ,. ````--...__\-. + // `.--. `-` "INFINTIY IS LESS ____ | |` + // `. `. THAN BEYOND" ,'`````. ; ;` + // `._`. __________ `. \'__/` + // `-:._____/______/___/____`. \ ` + // | `._ `. \ + // `._________`-. `. `.___ + // SSt `------'` function spaceship(a, b) { var diff = a - b; return (diff > 0) - (diff < 0); } /** - This will compare two javascript values of possibly different types. - It will tell you which one is greater than the other by returning: + Compares two javascript values and returns: - -1 if the first is smaller than the second, - 0 if both are equal, - 1 if the first is greater than the second. - The order is calculated based on `Ember.ORDER_DEFINITION`, if types are different. - In case they have the same type an appropriate comparison for this type is made. - ```javascript Ember.compare('hello', 'hello'); // 0 Ember.compare('abc', 'dfg'); // -1 Ember.compare(2, 1); // 1 ``` + If the types of the two objects are different precedence occurs in the + following order, with types earlier in the list considered `<` types + later in the list: + + - undefined + - null + - boolean + - number + - string + - array + - object + - instance + - function + - class + - date + + ```javascript + Ember.compare('hello', 50); // 1 + Ember.compare(50, 'hello'); // -1 + ``` + @method compare @for Ember @param {Object} v First value to compare @param {Object} w Second value to compare @return {Number} -1 if v < w, 0 if v = w and 1 if v > w. @@ -31293,23 +31699,25 @@ return ret; } /** - Creates a clone of the passed object. This function can take just about - any type of object and create a clone of it, including primitive values - (which are not actually cloned because they are immutable). + Creates a shallow copy of the passed object. A deep copy of the object is + returned if the optional `deep` argument is `true`. - If the passed object implements the `copy()` method, then this function - will simply call that method and return the result. Please see - `Ember.Copyable` for further details. + If the passed object implements the `Ember.Copyable` interface, then this + function will delegate to the object's `copy()` method and return the + result. See `Ember.Copyable` for further details. + For primitive values (which are immutable in JavaScript), the passed object + is simply returned. + @method copy @for Ember @param {Object} obj The object to clone - @param {Boolean} deep If true, a deep copy of the object is made - @return {Object} The cloned object + @param {Boolean} [deep=false] If true, a deep copy of the object is made. + @return {Object} The copied object @public */ function copy(obj, deep) { // fast paths @@ -31487,11 +31895,11 @@ return this; }; } }); // Ember.EXTEND_PROTOTYPES -enifed('ember-runtime/ext/rsvp', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/logger', 'ember-metal/run_loop', 'rsvp'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalLogger, _emberMetalRun_loop, _rsvp) { +enifed('ember-runtime/ext/rsvp', ['exports', 'ember-metal/core', 'require', 'ember-metal/debug', 'ember-metal/logger', 'ember-metal/run_loop', 'rsvp'], function (exports, _emberMetalCore, _require, _emberMetalDebug, _emberMetalLogger, _emberMetalRun_loop, _rsvp) { 'use strict'; exports.onerrorDefault = onerrorDefault; exports.after = after; @@ -31548,12 +31956,12 @@ } if (error && error.name !== 'TransitionAborted') { if (_emberMetalCore.default.testing) { // ES6TODO: remove when possible - if (!Test && _emberMetalCore.default.__loader.registry[testModuleName]) { - Test = requireModule(testModuleName)['default']; + if (!Test && _require.has(testModuleName)) { + Test = _require.default(testModuleName)['default']; } if (Test && Test.adapter) { Test.adapter.exception(error); _emberMetalLogger.default.error(error.stack); @@ -31687,10 +32095,120 @@ return _emberRuntimeSystemString.capitalize(this); }; } }); // Ember.EXTEND_PROTOTYPES +enifed('ember-runtime/index', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'ember-runtime/compare', 'ember-runtime/copy', 'ember-runtime/inject', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/container', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object_proxy', 'ember-runtime/system/core_object', 'ember-runtime/system/native_array', 'ember-runtime/system/string', 'ember-runtime/system/lazy_load', 'ember-runtime/mixins/array', 'ember-runtime/mixins/comparable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/freezable', 'ember-runtime/mixins/-proxy', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/target_action_support', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/controllers/controller', 'ember-runtime/mixins/controller', 'ember-runtime/system/service', 'ember-runtime/ext/rsvp', 'ember-runtime/ext/string', 'ember-runtime/ext/function', 'ember-runtime/utils', 'ember-metal/features', 'ember-runtime/mixins/registry_proxy', 'ember-runtime/mixins/container_proxy', 'ember-runtime/string_registry'], function (exports, _emberMetal, _emberRuntimeIsEqual, _emberRuntimeCompare, _emberRuntimeCopy, _emberRuntimeInject, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemContainer, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemObject_proxy, _emberRuntimeSystemCore_object, _emberRuntimeSystemNative_array, _emberRuntimeSystemString, _emberRuntimeSystemLazy_load, _emberRuntimeMixinsArray, _emberRuntimeMixinsComparable, _emberRuntimeMixinsCopyable, _emberRuntimeMixinsEnumerable, _emberRuntimeMixinsFreezable, _emberRuntimeMixinsProxy, _emberRuntimeMixinsObservable, _emberRuntimeMixinsAction_handler, _emberRuntimeMixinsMutable_enumerable, _emberRuntimeMixinsMutable_array, _emberRuntimeMixinsTarget_action_support, _emberRuntimeMixinsEvented, _emberRuntimeMixinsPromise_proxy, _emberRuntimeComputedReduce_computed_macros, _emberRuntimeControllersController, _emberRuntimeMixinsController, _emberRuntimeSystemService, _emberRuntimeExtRsvp, _emberRuntimeExtString, _emberRuntimeExtFunction, _emberRuntimeUtils, _emberMetalFeatures, _emberRuntimeMixinsRegistry_proxy, _emberRuntimeMixinsContainer_proxy, _emberRuntimeString_registry) { + /** + @module ember + @submodule ember-runtime + */ + + // BEGIN IMPORTS + 'use strict'; + + // END IMPORTS + + // BEGIN EXPORTS + _emberMetal.default.compare = _emberRuntimeCompare.default; + _emberMetal.default.copy = _emberRuntimeCopy.default; + _emberMetal.default.isEqual = _emberRuntimeIsEqual.default; + + _emberMetal.default.inject = _emberRuntimeInject.default; + + _emberMetal.default.Array = _emberRuntimeMixinsArray.default; + + _emberMetal.default.Comparable = _emberRuntimeMixinsComparable.default; + _emberMetal.default.Copyable = _emberRuntimeMixinsCopyable.default; + + _emberMetal.default.Freezable = _emberRuntimeMixinsFreezable.Freezable; + _emberMetal.default.FROZEN_ERROR = _emberRuntimeMixinsFreezable.FROZEN_ERROR; + + _emberMetal.default.MutableEnumerable = _emberRuntimeMixinsMutable_enumerable.default; + _emberMetal.default.MutableArray = _emberRuntimeMixinsMutable_array.default; + + _emberMetal.default.TargetActionSupport = _emberRuntimeMixinsTarget_action_support.default; + _emberMetal.default.Evented = _emberRuntimeMixinsEvented.default; + + _emberMetal.default.PromiseProxyMixin = _emberRuntimeMixinsPromise_proxy.default; + + _emberMetal.default.Observable = _emberRuntimeMixinsObservable.default; + + _emberMetal.default.typeOf = _emberRuntimeUtils.typeOf; + _emberMetal.default.isArray = _emberRuntimeUtils.isArray; + + // ES6TODO: this seems a less than ideal way/place to add properties to Ember.computed + var EmComputed = _emberMetal.default.computed; + + EmComputed.sum = _emberRuntimeComputedReduce_computed_macros.sum; + EmComputed.min = _emberRuntimeComputedReduce_computed_macros.min; + EmComputed.max = _emberRuntimeComputedReduce_computed_macros.max; + EmComputed.map = _emberRuntimeComputedReduce_computed_macros.map; + EmComputed.sort = _emberRuntimeComputedReduce_computed_macros.sort; + EmComputed.setDiff = _emberRuntimeComputedReduce_computed_macros.setDiff; + EmComputed.mapBy = _emberRuntimeComputedReduce_computed_macros.mapBy; + EmComputed.filter = _emberRuntimeComputedReduce_computed_macros.filter; + EmComputed.filterBy = _emberRuntimeComputedReduce_computed_macros.filterBy; + EmComputed.uniq = _emberRuntimeComputedReduce_computed_macros.uniq; + EmComputed.union = _emberRuntimeComputedReduce_computed_macros.union; + EmComputed.intersect = _emberRuntimeComputedReduce_computed_macros.intersect; + EmComputed.collect = _emberRuntimeComputedReduce_computed_macros.collect; + + _emberMetal.default.String = _emberRuntimeSystemString.default; + _emberMetal.default.Object = _emberRuntimeSystemObject.default; + _emberMetal.default.Container = _emberRuntimeSystemContainer.Container; + _emberMetal.default.Registry = _emberRuntimeSystemContainer.Registry; + + _emberMetal.default.getOwner = _emberRuntimeSystemContainer.getOwner; + _emberMetal.default.setOwner = _emberRuntimeSystemContainer.setOwner; + + _emberMetal.default._RegistryProxyMixin = _emberRuntimeMixinsRegistry_proxy.default; + _emberMetal.default._ContainerProxyMixin = _emberRuntimeMixinsContainer_proxy.default; + + _emberMetal.default.Namespace = _emberRuntimeSystemNamespace.default; + _emberMetal.default.Enumerable = _emberRuntimeMixinsEnumerable.default; + _emberMetal.default.ArrayProxy = _emberRuntimeSystemArray_proxy.default; + _emberMetal.default.ObjectProxy = _emberRuntimeSystemObject_proxy.default; + _emberMetal.default.ActionHandler = _emberRuntimeMixinsAction_handler.default; + _emberMetal.default.CoreObject = _emberRuntimeSystemCore_object.default; + _emberMetal.default.NativeArray = _emberRuntimeSystemNative_array.default; + // ES6TODO: Currently we must rely on the global from ember-metal/core to avoid circular deps + // Ember.A = A; + _emberMetal.default.onLoad = _emberRuntimeSystemLazy_load.onLoad; + _emberMetal.default.runLoadHooks = _emberRuntimeSystemLazy_load.runLoadHooks; + + _emberMetal.default.Controller = _emberRuntimeControllersController.default; + _emberMetal.default.ControllerMixin = _emberRuntimeMixinsController.default; + + _emberMetal.default.Service = _emberRuntimeSystemService.default; + + _emberMetal.default._ProxyMixin = _emberRuntimeMixinsProxy.default; + + _emberMetal.default.RSVP = _emberRuntimeExtRsvp.default; + // END EXPORTS + + /** + Defines the hash of localized strings for the current language. Used by + the `Ember.String.loc()` helper. To localize, add string values to this + hash. + + @property STRINGS + @for Ember + @type Object + @private + */ + Object.defineProperty(_emberMetal.default, 'STRINGS', { + configurable: false, + get: _emberRuntimeString_registry.getStrings, + set: _emberRuntimeString_registry.setStrings + }); + + exports.default = _emberMetal.default; +}); +// just for side effect of extending Ember.RSVP +// just for side effect of extending String.prototype +// just for side effect of extending Function.prototype enifed('ember-runtime/inject', ['exports', 'ember-metal/debug', 'ember-metal/injected_property'], function (exports, _emberMetalDebug, _emberMetalInjected_property) { 'use strict'; exports.default = inject; exports.createInjectionHelper = createInjectionHelper; @@ -31769,20 +32287,38 @@ return true; } }); enifed('ember-runtime/is-equal', ['exports'], function (exports) { /** - Compares two objects, returning true if they are logically equal. This is - a deeper comparison than a simple triple equal. For sets it will compare the - internal objects. For any other object that implements `isEqual()` it will - respect that method. + Compares two objects, returning true if they are equal. ```javascript Ember.isEqual('hello', 'hello'); // true Ember.isEqual(1, 2); // false + ``` + + `isEqual` is a more specific comparison than a triple equal comparison. + It will call the `isEqual` instance method on the objects being + compared, allowing finer control over when objects should be considered + equal to each other. + + ```javascript + let Person = Ember.Object.extend({ + isEqual(other) { return this.ssn == other.ssn; } + }); + + let personA = Person.create({name: 'Muhammad Ali', ssn: '123-45-6789'}); + let personB = Person.create({name: 'Cassius Clay', ssn: '123-45-6789'}); + + Ember.isEqual(personA, personB); // true + ``` + + Due to the expense of array comparisons, collections will never be equal to + each other even if each of their items are equal to each other. + + ```javascript Ember.isEqual([4, 2], [4, 2]); // false - Ember.isEqual({ isEqual() { return true;} }, null) // true ``` @method isEqual @for Ember @param {Object} a first object to compare @@ -31960,11 +32496,11 @@ ... } } }); ``` - It is also possible to call `this._super.apply(this, arguments)` from within an + It is also possible to call `this._super(...arguments)` from within an action handler if it overrides a handler defined on a parent class or mixin: Take for example the following routes: ```js App.DebugRoute = Ember.Mixin.create({ @@ -31976,11 +32512,11 @@ }); App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, { actions: { debugRouteInformation: function() { // also call the debugRouteInformation of mixed in App.DebugRoute - this._super.apply(this, arguments); + this._super(...arguments); // show additional annoyance window.alert(...); } } }); @@ -32396,11 +32932,11 @@ * `arrayWillChange(observedObj, start, removeCount, addCount)` - This method will be called just before the array is modified. * `arrayDidChange(observedObj, start, removeCount, addCount)` - This method will be called just after the array is modified. Both callbacks will be passed the observed object, starting index of the - change as well a a count of the items to be removed and added. You can use + change as well as a count of the items to be removed and added. You can use these callbacks to optionally inspect the array during the change, clear caches, or do any other bookkeeping necessary. In addition to passing a target, you can also include an options hash which you can use to override the method names that will be invoked on the target. @@ -35081,11 +35617,11 @@ proxy.get('isSettled') //=> false proxy.get('isRejected') //=> false proxy.get('isFulfilled') //=> false ``` - When the the $.getJSON completes, and the promise is fulfilled + When the $.getJSON completes, and the promise is fulfilled with json, the life cycle attributes will update accordingly. ```javascript proxy.get('isPending') //=> false proxy.get('isSettled') //=> true @@ -36227,11 +36763,11 @@ name: "Steve" }); // alerts 'Name is Steve'. ``` NOTE: If you do override `init` for a framework class like `Ember.View`, - be sure to call `this._super.apply(this, arguments)` in your + be sure to call `this._super(...arguments)` in your `init` declaration! If you don't, Ember may not have an opportunity to do important setup work, and you'll see strange behavior in your application. @method init @public @@ -37392,11 +37928,11 @@ var Pagination = Ember.CollectionView.extend({ tagName: 'ul', classNames: ['pagination'], init: function() { - this._super.apply(this, arguments); + this._super(...arguments); if (!this.get('content')) { this.set('content', Ember.A()); } } }); @@ -37909,18 +38445,18 @@ var toString = Object.prototype.toString; /** Returns true if the passed object is an array or Array-like. - Ember Array Protocol: + Objects are considered Array-like if any of the following are true: - - the object has an objectAt property - the object is a native Array + - the object has an objectAt property - the object is an Object, and has a length property Unlike `Ember.typeOf` this method returns true even if the passed object is - not formally array but appears to be array-like (i.e. implements `Ember.Array`) + not formally an array but appears to be array-like (i.e. implements `Ember.Array`) ```javascript Ember.isArray(); // false Ember.isArray([]); // true Ember.isArray(Ember.ArrayProxy.create({ content: [] })); // true @@ -37953,11 +38489,11 @@ } return false; } /** - Returns a consistent type for the passed item. + Returns a consistent type for the passed object. Use this instead of the built-in `typeof` to get the type of an item. It will return the same result across all browsers and includes a bit more detail. Here is what will be returned: @@ -38032,132 +38568,22 @@ } return ret; } }); -enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'ember-runtime/compare', 'ember-runtime/copy', 'ember-runtime/inject', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/container', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object_proxy', 'ember-runtime/system/core_object', 'ember-runtime/system/native_array', 'ember-runtime/system/string', 'ember-runtime/system/lazy_load', 'ember-runtime/mixins/array', 'ember-runtime/mixins/comparable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/freezable', 'ember-runtime/mixins/-proxy', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/target_action_support', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/controllers/controller', 'ember-runtime/mixins/controller', 'ember-runtime/system/service', 'ember-runtime/ext/rsvp', 'ember-runtime/ext/string', 'ember-runtime/ext/function', 'ember-runtime/utils', 'ember-metal/features', 'ember-runtime/mixins/registry_proxy', 'ember-runtime/mixins/container_proxy', 'ember-runtime/string_registry'], function (exports, _emberMetal, _emberRuntimeIsEqual, _emberRuntimeCompare, _emberRuntimeCopy, _emberRuntimeInject, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemContainer, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemObject_proxy, _emberRuntimeSystemCore_object, _emberRuntimeSystemNative_array, _emberRuntimeSystemString, _emberRuntimeSystemLazy_load, _emberRuntimeMixinsArray, _emberRuntimeMixinsComparable, _emberRuntimeMixinsCopyable, _emberRuntimeMixinsEnumerable, _emberRuntimeMixinsFreezable, _emberRuntimeMixinsProxy, _emberRuntimeMixinsObservable, _emberRuntimeMixinsAction_handler, _emberRuntimeMixinsMutable_enumerable, _emberRuntimeMixinsMutable_array, _emberRuntimeMixinsTarget_action_support, _emberRuntimeMixinsEvented, _emberRuntimeMixinsPromise_proxy, _emberRuntimeComputedReduce_computed_macros, _emberRuntimeControllersController, _emberRuntimeMixinsController, _emberRuntimeSystemService, _emberRuntimeExtRsvp, _emberRuntimeExtString, _emberRuntimeExtFunction, _emberRuntimeUtils, _emberMetalFeatures, _emberRuntimeMixinsRegistry_proxy, _emberRuntimeMixinsContainer_proxy, _emberRuntimeString_registry) { +enifed('ember-template-compiler/compat/precompile', ['exports', 'require', 'ember-template-compiler/system/compile_options'], function (exports, _require, _emberTemplateCompilerSystemCompile_options) { /** @module ember - @submodule ember-runtime - */ - - // BEGIN IMPORTS - 'use strict'; - - // END IMPORTS - - // BEGIN EXPORTS - _emberMetal.default.compare = _emberRuntimeCompare.default; - _emberMetal.default.copy = _emberRuntimeCopy.default; - _emberMetal.default.isEqual = _emberRuntimeIsEqual.default; - - _emberMetal.default.inject = _emberRuntimeInject.default; - - _emberMetal.default.Array = _emberRuntimeMixinsArray.default; - - _emberMetal.default.Comparable = _emberRuntimeMixinsComparable.default; - _emberMetal.default.Copyable = _emberRuntimeMixinsCopyable.default; - - _emberMetal.default.Freezable = _emberRuntimeMixinsFreezable.Freezable; - _emberMetal.default.FROZEN_ERROR = _emberRuntimeMixinsFreezable.FROZEN_ERROR; - - _emberMetal.default.MutableEnumerable = _emberRuntimeMixinsMutable_enumerable.default; - _emberMetal.default.MutableArray = _emberRuntimeMixinsMutable_array.default; - - _emberMetal.default.TargetActionSupport = _emberRuntimeMixinsTarget_action_support.default; - _emberMetal.default.Evented = _emberRuntimeMixinsEvented.default; - - _emberMetal.default.PromiseProxyMixin = _emberRuntimeMixinsPromise_proxy.default; - - _emberMetal.default.Observable = _emberRuntimeMixinsObservable.default; - - _emberMetal.default.typeOf = _emberRuntimeUtils.typeOf; - _emberMetal.default.isArray = _emberRuntimeUtils.isArray; - - // ES6TODO: this seems a less than ideal way/place to add properties to Ember.computed - var EmComputed = _emberMetal.default.computed; - - EmComputed.sum = _emberRuntimeComputedReduce_computed_macros.sum; - EmComputed.min = _emberRuntimeComputedReduce_computed_macros.min; - EmComputed.max = _emberRuntimeComputedReduce_computed_macros.max; - EmComputed.map = _emberRuntimeComputedReduce_computed_macros.map; - EmComputed.sort = _emberRuntimeComputedReduce_computed_macros.sort; - EmComputed.setDiff = _emberRuntimeComputedReduce_computed_macros.setDiff; - EmComputed.mapBy = _emberRuntimeComputedReduce_computed_macros.mapBy; - EmComputed.filter = _emberRuntimeComputedReduce_computed_macros.filter; - EmComputed.filterBy = _emberRuntimeComputedReduce_computed_macros.filterBy; - EmComputed.uniq = _emberRuntimeComputedReduce_computed_macros.uniq; - EmComputed.union = _emberRuntimeComputedReduce_computed_macros.union; - EmComputed.intersect = _emberRuntimeComputedReduce_computed_macros.intersect; - EmComputed.collect = _emberRuntimeComputedReduce_computed_macros.collect; - - _emberMetal.default.String = _emberRuntimeSystemString.default; - _emberMetal.default.Object = _emberRuntimeSystemObject.default; - _emberMetal.default.Container = _emberRuntimeSystemContainer.Container; - _emberMetal.default.Registry = _emberRuntimeSystemContainer.Registry; - - _emberMetal.default.getOwner = _emberRuntimeSystemContainer.getOwner; - _emberMetal.default.setOwner = _emberRuntimeSystemContainer.setOwner; - - _emberMetal.default._RegistryProxyMixin = _emberRuntimeMixinsRegistry_proxy.default; - _emberMetal.default._ContainerProxyMixin = _emberRuntimeMixinsContainer_proxy.default; - - _emberMetal.default.Namespace = _emberRuntimeSystemNamespace.default; - _emberMetal.default.Enumerable = _emberRuntimeMixinsEnumerable.default; - _emberMetal.default.ArrayProxy = _emberRuntimeSystemArray_proxy.default; - _emberMetal.default.ObjectProxy = _emberRuntimeSystemObject_proxy.default; - _emberMetal.default.ActionHandler = _emberRuntimeMixinsAction_handler.default; - _emberMetal.default.CoreObject = _emberRuntimeSystemCore_object.default; - _emberMetal.default.NativeArray = _emberRuntimeSystemNative_array.default; - // ES6TODO: Currently we must rely on the global from ember-metal/core to avoid circular deps - // Ember.A = A; - _emberMetal.default.onLoad = _emberRuntimeSystemLazy_load.onLoad; - _emberMetal.default.runLoadHooks = _emberRuntimeSystemLazy_load.runLoadHooks; - - _emberMetal.default.Controller = _emberRuntimeControllersController.default; - _emberMetal.default.ControllerMixin = _emberRuntimeMixinsController.default; - - _emberMetal.default.Service = _emberRuntimeSystemService.default; - - _emberMetal.default._ProxyMixin = _emberRuntimeMixinsProxy.default; - - _emberMetal.default.RSVP = _emberRuntimeExtRsvp.default; - // END EXPORTS - - /** - Defines the hash of localized strings for the current language. Used by - the `Ember.String.loc()` helper. To localize, add string values to this - hash. - - @property STRINGS - @for Ember - @type Object - @private - */ - Object.defineProperty(_emberMetal.default, 'STRINGS', { - configurable: false, - get: _emberRuntimeString_registry.getStrings, - set: _emberRuntimeString_registry.setStrings - }); - - exports.default = _emberMetal.default; -}); -// just for side effect of extending Ember.RSVP -// just for side effect of extending String.prototype -// just for side effect of extending Function.prototype -enifed('ember-template-compiler/compat/precompile', ['exports', 'ember-metal/core', 'ember-template-compiler/system/compile_options'], function (exports, _emberMetalCore, _emberTemplateCompilerSystemCompile_options) { - /** - @module ember @submodule ember-template-compiler */ 'use strict'; var compile, compileSpec; exports.default = function (string) { - if ((!compile || !compileSpec) && _emberMetalCore.default.__loader.registry['htmlbars-compiler/compiler']) { - var Compiler = requireModule('htmlbars-compiler/compiler'); + if ((!compile || !compileSpec) && _require.has('htmlbars-compiler/compiler')) { + var Compiler = _require.default('htmlbars-compiler/compiler'); compile = Compiler.compile; compileSpec = Compiler.compileSpec; } @@ -38178,10 +38604,38 @@ EmberHandlebars.precompile = _emberTemplateCompilerCompatPrecompile.default; EmberHandlebars.compile = _emberTemplateCompilerSystemCompile.default; EmberHandlebars.template = _emberTemplateCompilerSystemTemplate.default; }); +enifed('ember-template-compiler/index', ['exports', 'ember-metal', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-old-binding-syntax', 'ember-template-compiler/plugins/transform-old-class-binding-syntax', 'ember-template-compiler/plugins/transform-item-class', 'ember-template-compiler/plugins/transform-component-attrs-into-mut', 'ember-template-compiler/plugins/transform-component-curly-to-readonly', 'ember-template-compiler/plugins/transform-angle-bracket-components', 'ember-template-compiler/plugins/transform-input-on-to-onEvent', 'ember-template-compiler/plugins/transform-top-level-components', 'ember-template-compiler/plugins/transform-each-into-collection', 'ember-template-compiler/plugins/transform-unescaped-inline-link-to', 'ember-template-compiler/plugins/assert-no-view-and-controller-paths', 'ember-template-compiler/plugins/assert-no-view-helper', 'ember-template-compiler/compat'], function (exports, _emberMetal, _emberTemplateCompilerSystemPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemTemplate, _emberTemplateCompilerPlugins, _emberTemplateCompilerPluginsTransformOldBindingSyntax, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax, _emberTemplateCompilerPluginsTransformItemClass, _emberTemplateCompilerPluginsTransformComponentAttrsIntoMut, _emberTemplateCompilerPluginsTransformComponentCurlyToReadonly, _emberTemplateCompilerPluginsTransformAngleBracketComponents, _emberTemplateCompilerPluginsTransformInputOnToOnEvent, _emberTemplateCompilerPluginsTransformTopLevelComponents, _emberTemplateCompilerPluginsTransformEachIntoCollection, _emberTemplateCompilerPluginsTransformUnescapedInlineLinkTo, _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths, _emberTemplateCompilerPluginsAssertNoViewHelper, _emberTemplateCompilerCompat) { + 'use strict'; + + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformOldBindingSyntax.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformOldClassBindingSyntax.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformItemClass.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformComponentAttrsIntoMut.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformComponentCurlyToReadonly.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformAngleBracketComponents.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformInputOnToOnEvent.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformTopLevelComponents.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformUnescapedInlineLinkTo.default); + + if (_emberMetal.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformEachIntoCollection.default); + } else { + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default); + _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsAssertNoViewHelper.default); + } + + exports._Ember = _emberMetal.default; + exports.precompile = _emberTemplateCompilerSystemPrecompile.default; + exports.compile = _emberTemplateCompilerSystemCompile.default; + exports.template = _emberTemplateCompilerSystemTemplate.default; + exports.registerPlugin = _emberTemplateCompilerPlugins.registerPlugin; +}); + +// used for adding Ember.Handlebars.compile for backwards compat enifed('ember-template-compiler/plugins/assert-no-view-and-controller-paths', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetalCore, _emberMetalDebug, _emberTemplateCompilerSystemCalculateLocationDisplay) { 'use strict'; function AssertNoViewAndControllerPaths(options) { // set later within HTMLBars to the syntax package @@ -39121,11 +39575,11 @@ } return moduleInfo; } }); -enifed('ember-template-compiler/system/compile', ['exports', 'ember-metal/core', 'ember-template-compiler/system/compile_options', 'ember-template-compiler/system/template'], function (exports, _emberMetalCore, _emberTemplateCompilerSystemCompile_options, _emberTemplateCompilerSystemTemplate) { +enifed('ember-template-compiler/system/compile', ['exports', 'require', 'ember-template-compiler/system/compile_options', 'ember-template-compiler/system/template'], function (exports, _require, _emberTemplateCompilerSystemCompile_options, _emberTemplateCompilerSystemTemplate) { /** @module ember @submodule ember-template-compiler */ @@ -39143,12 +39597,12 @@ @param {String} templateString This is the string to be compiled by HTMLBars. @param {Object} options This is an options hash to augment the compiler options. */ exports.default = function (templateString, options) { - if (!compile && _emberMetalCore.default.__loader.registry['htmlbars-compiler/compiler']) { - compile = requireModule('htmlbars-compiler/compiler').compile; + if (!compile && _require.has('htmlbars-compiler/compiler')) { + compile = _require.default('htmlbars-compiler/compiler').compile; } if (!compile) { throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.'); } @@ -39196,11 +39650,11 @@ options.plugins = plugins; options.buildMeta = function buildMeta(program) { return { fragmentReason: fragmentReason(program), - revision: 'Ember@2.3.2', + revision: 'Ember@2.4.0-beta.2', loc: program.loc, moduleName: options.moduleName }; }; @@ -39262,11 +39716,11 @@ } else { return false; } } }); -enifed('ember-template-compiler/system/precompile', ['exports', 'ember-metal/core', 'ember-template-compiler/system/compile_options'], function (exports, _emberMetalCore, _emberTemplateCompilerSystemCompile_options) { +enifed('ember-template-compiler/system/precompile', ['exports', 'require', 'ember-template-compiler/system/compile_options'], function (exports, _require, _emberTemplateCompilerSystemCompile_options) { /** @module ember @submodule ember-template-compiler */ 'use strict'; @@ -39283,12 +39737,12 @@ @method precompile @param {String} templateString This is the string to be compiled by HTMLBars. */ exports.default = function (templateString, options) { - if (!compileSpec && _emberMetalCore.default.__loader.registry['htmlbars-compiler/compiler']) { - compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec; + if (!compileSpec && _require.has('htmlbars-compiler/compiler')) { + compileSpec = _require.default('htmlbars-compiler/compiler').compileSpec; } if (!compileSpec) { throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.'); } @@ -39322,38 +39776,10 @@ templateSpec.isMethod = false; return templateSpec; }; }); -enifed('ember-template-compiler', ['exports', 'ember-metal', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-old-binding-syntax', 'ember-template-compiler/plugins/transform-old-class-binding-syntax', 'ember-template-compiler/plugins/transform-item-class', 'ember-template-compiler/plugins/transform-component-attrs-into-mut', 'ember-template-compiler/plugins/transform-component-curly-to-readonly', 'ember-template-compiler/plugins/transform-angle-bracket-components', 'ember-template-compiler/plugins/transform-input-on-to-onEvent', 'ember-template-compiler/plugins/transform-top-level-components', 'ember-template-compiler/plugins/transform-each-into-collection', 'ember-template-compiler/plugins/transform-unescaped-inline-link-to', 'ember-template-compiler/plugins/assert-no-view-and-controller-paths', 'ember-template-compiler/plugins/assert-no-view-helper', 'ember-template-compiler/compat'], function (exports, _emberMetal, _emberTemplateCompilerSystemPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemTemplate, _emberTemplateCompilerPlugins, _emberTemplateCompilerPluginsTransformOldBindingSyntax, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax, _emberTemplateCompilerPluginsTransformItemClass, _emberTemplateCompilerPluginsTransformComponentAttrsIntoMut, _emberTemplateCompilerPluginsTransformComponentCurlyToReadonly, _emberTemplateCompilerPluginsTransformAngleBracketComponents, _emberTemplateCompilerPluginsTransformInputOnToOnEvent, _emberTemplateCompilerPluginsTransformTopLevelComponents, _emberTemplateCompilerPluginsTransformEachIntoCollection, _emberTemplateCompilerPluginsTransformUnescapedInlineLinkTo, _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths, _emberTemplateCompilerPluginsAssertNoViewHelper, _emberTemplateCompilerCompat) { - 'use strict'; - - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformOldBindingSyntax.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformOldClassBindingSyntax.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformItemClass.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformComponentAttrsIntoMut.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformComponentCurlyToReadonly.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformAngleBracketComponents.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformInputOnToOnEvent.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformTopLevelComponents.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformUnescapedInlineLinkTo.default); - - if (_emberMetal.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformEachIntoCollection.default); - } else { - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default); - _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsAssertNoViewHelper.default); - } - - exports._Ember = _emberMetal.default; - exports.precompile = _emberTemplateCompilerSystemPrecompile.default; - exports.compile = _emberTemplateCompilerSystemCompile.default; - exports.template = _emberTemplateCompilerSystemTemplate.default; - exports.registerPlugin = _emberTemplateCompilerPlugins.registerPlugin; -}); - -// used for adding Ember.Handlebars.compile for backwards compat enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/object'], function (exports, _emberRuntimeSystemObject) { 'use strict'; function K() { return this; @@ -39897,10 +40323,27 @@ @since 1.5.0 @public */ asyncHelper('triggerEvent', triggerEvent); }); +enifed('ember-testing/index', ['exports', 'ember-metal/core', 'ember-testing/initializers', 'ember-testing/support', 'ember-testing/setup_for_testing', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit', 'ember-testing/helpers'], function (exports, _emberMetalCore, _emberTestingInitializers, _emberTestingSupport, _emberTestingSetup_for_testing, _emberTestingTest, _emberTestingAdaptersAdapter, _emberTestingAdaptersQunit, _emberTestingHelpers) { + 'use strict'; + + // adds helpers to helpers object in Test + + /** + @module ember + @submodule ember-testing + */ + + _emberMetalCore.default.Test = _emberTestingTest.default; + _emberMetalCore.default.Test.Adapter = _emberTestingAdaptersAdapter.default; + _emberMetalCore.default.Test.QUnitAdapter = _emberTestingAdaptersQunit.default; + _emberMetalCore.default.setupForTesting = _emberTestingSetup_for_testing.default; +}); +// to setup initializer +// to handle various edge cases enifed('ember-testing/initializers', ['exports', 'ember-runtime/system/lazy_load'], function (exports, _emberRuntimeSystemLazy_load) { 'use strict'; var name = 'deferReadiness in `testing` mode'; @@ -40516,27 +40959,10 @@ } } exports.default = Test; }); -enifed('ember-testing', ['exports', 'ember-metal/core', 'ember-testing/initializers', 'ember-testing/support', 'ember-testing/setup_for_testing', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit', 'ember-testing/helpers'], function (exports, _emberMetalCore, _emberTestingInitializers, _emberTestingSupport, _emberTestingSetup_for_testing, _emberTestingTest, _emberTestingAdaptersAdapter, _emberTestingAdaptersQunit, _emberTestingHelpers) { - 'use strict'; - - // adds helpers to helpers object in Test - - /** - @module ember - @submodule ember-testing - */ - - _emberMetalCore.default.Test = _emberTestingTest.default; - _emberMetalCore.default.Test.Adapter = _emberTestingAdaptersAdapter.default; - _emberMetalCore.default.Test.QUnitAdapter = _emberTestingAdaptersQunit.default; - _emberMetalCore.default.setupForTesting = _emberTestingSetup_for_testing.default; -}); -// to setup initializer -// to handle various edge cases enifed('ember-views/compat/attrs-proxy', ['exports', 'ember-metal/mixin', 'ember-metal/symbol', 'ember-metal/property_events'], function (exports, _emberMetalMixin, _emberMetalSymbol, _emberMetalProperty_events) { 'use strict'; exports.deprecation = deprecation; @@ -40675,26 +41101,26 @@ } return Component; } }, - componentFor: function (name, owner) { + componentFor: function (name, owner, options) { if (this.invalidName(name)) { return; } var fullName = 'component:' + name; - return owner._lookupFactory(fullName); + return owner._lookupFactory(fullName, options); }, - layoutFor: function (name, owner) { + layoutFor: function (name, owner, options) { if (this.invalidName(name)) { return; } var templateFullName = 'template:components/' + name; - return owner.lookup(templateFullName); + return owner.lookup(templateFullName, options); } }); }); enifed('ember-views/components/component', ['exports', 'ember-metal/debug', 'ember-metal/environment', 'ember-runtime/mixins/target_action_support', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/utils', 'ember-metal/computed', 'ember-views/compat/attrs-proxy', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalEnvironment, _emberRuntimeMixinsTarget_action_support, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalIs_none, _emberMetalUtils, _emberMetalComputed, _emberViewsCompatAttrsProxy, _containerOwner) { 'use strict'; @@ -41128,10 +41554,79 @@ isComponentFactory: true }); exports.default = Component; }); +enifed('ember-views/index', ['exports', 'ember-runtime', 'ember-views/system/jquery', 'ember-views/system/utils', 'ember-views/system/ext', 'ember-views/views/states', 'ember-metal-views/renderer', 'ember-views/views/core_view', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-views/views/collection_view', 'ember-views/components/component', 'ember-views/system/event_dispatcher', 'ember-views/mixins/view_target_action_support', 'ember-views/component_lookup', 'ember-views/views/checkbox', 'ember-views/mixins/text_support', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/select', 'ember-views/compat/metamorph_view', 'ember-views/views/legacy_each_view'], function (exports, _emberRuntime, _emberViewsSystemJquery, _emberViewsSystemUtils, _emberViewsSystemExt, _emberViewsViewsStates, _emberMetalViewsRenderer, _emberViewsViewsCore_view, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberViewsViewsCollection_view, _emberViewsComponentsComponent, _emberViewsSystemEvent_dispatcher, _emberViewsMixinsView_target_action_support, _emberViewsComponent_lookup, _emberViewsViewsCheckbox, _emberViewsMixinsText_support, _emberViewsViewsText_field, _emberViewsViewsText_area, _emberViewsViewsSelect, _emberViewsCompatMetamorph_view, _emberViewsViewsLegacy_each_view) { + /** + @module ember + @submodule ember-views + */ + + // BEGIN IMPORTS + 'use strict'; + + // END IMPORTS + + /** + Alias for jQuery + + @method $ + @for Ember + @public + */ + + // BEGIN EXPORTS + _emberRuntime.default.$ = _emberViewsSystemJquery.default; + + _emberRuntime.default.ViewTargetActionSupport = _emberViewsMixinsView_target_action_support.default; + + var ViewUtils = _emberRuntime.default.ViewUtils = {}; + ViewUtils.isSimpleClick = _emberViewsSystemUtils.isSimpleClick; + ViewUtils.getViewClientRects = _emberViewsSystemUtils.getViewClientRects; + ViewUtils.getViewBoundingClientRect = _emberViewsSystemUtils.getViewBoundingClientRect; + + if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + _emberRuntime.default.CoreView = _emberViewsViewsCore_view.DeprecatedCoreView; + _emberRuntime.default.View = _emberViewsViewsView.DeprecatedView; + _emberRuntime.default.View.states = _emberViewsViewsStates.states; + _emberRuntime.default.View.cloneStates = _emberViewsViewsStates.cloneStates; + _emberRuntime.default.View._Renderer = _emberMetalViewsRenderer.default; + _emberRuntime.default.ContainerView = _emberViewsViewsContainer_view.DeprecatedContainerView; + _emberRuntime.default.CollectionView = _emberViewsViewsCollection_view.default; + } + + _emberRuntime.default._Renderer = _emberMetalViewsRenderer.default; + + _emberRuntime.default.Checkbox = _emberViewsViewsCheckbox.default; + _emberRuntime.default.TextField = _emberViewsViewsText_field.default; + _emberRuntime.default.TextArea = _emberViewsViewsText_area.default; + + if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + _emberRuntime.default.Select = _emberViewsViewsSelect.Select; + } + + _emberRuntime.default.SelectOption = _emberViewsViewsSelect.SelectOption; + _emberRuntime.default.SelectOptgroup = _emberViewsViewsSelect.SelectOptgroup; + + _emberRuntime.default.TextSupport = _emberViewsMixinsText_support.default; + _emberRuntime.default.ComponentLookup = _emberViewsComponent_lookup.default; + _emberRuntime.default.Component = _emberViewsComponentsComponent.default; + _emberRuntime.default.EventDispatcher = _emberViewsSystemEvent_dispatcher.default; + + // Deprecated: + if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { + _emberRuntime.default._Metamorph = _emberViewsCompatMetamorph_view._Metamorph; + _emberRuntime.default._MetamorphView = _emberViewsCompatMetamorph_view.default; + _emberRuntime.default._LegacyEachView = _emberViewsViewsLegacy_each_view.default; + } + + // END EXPORTS + + exports.default = _emberRuntime.default; +}); +// for the side effect of extending Ember.run.queues enifed('ember-views/mixins/aria_role_support', ['exports', 'ember-metal/mixin'], function (exports, _emberMetalMixin) { /** @module ember @submodule ember-views */ @@ -41335,11 +41830,14 @@ enifed('ember-views/mixins/legacy_child_views_support', ['exports', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set', 'container/owner'], function (exports, _emberMetalMixin, _emberMetalProperty_get, _emberMetalProperty_set, _containerOwner) { 'use strict'; exports.default = _emberMetalMixin.Mixin.create({ linkChild: function (instance) { - _containerOwner.setOwner(instance, _containerOwner.getOwner(this)); + if (!instance[_containerOwner.OWNER]) { + _containerOwner.setOwner(instance, _containerOwner.getOwner(this)); + } + if (_emberMetalProperty_get.get(instance, 'parentView') !== this) { // linkChild should be idempotent _emberMetalProperty_set.set(instance, 'parentView', this); instance.trigger('parentViewDidChange'); } @@ -41943,11 +42441,14 @@ return view; }, linkChild: function (instance) { - _containerOwner.setOwner(instance, _containerOwner.getOwner(this)); + if (!instance[_containerOwner.OWNER]) { + _containerOwner.setOwner(instance, _containerOwner.getOwner(this)); + } + instance.parentView = this; instance.ownerView = this.ownerView; }, unlinkChild: function (instance) { @@ -43826,11 +44327,11 @@ 'use strict'; // Add a new named queue for rendering views that happens // after bindings have synced, and a queue for scheduling actions - // that that should occur after view rendering. + // that should occur after view rendering. _emberMetalRun_loop.default._addQueue('render', 'actions'); _emberMetalRun_loop.default._addQueue('afterRender', 'render'); }); enifed('ember-views/system/jquery', ['exports', 'ember-metal/core', 'ember-metal/environment'], function (exports, _emberMetalCore, _emberMetalEnvironment) { 'use strict'; @@ -44489,11 +44990,11 @@ exports.DeprecatedCollectionView = DeprecatedCollectionView; }); enifed('ember-views/views/container_view', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-runtime/mixins/mutable_array', 'ember-runtime/system/native_array', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-metal/events', 'ember-htmlbars/templates/container-view'], function (exports, _emberMetalCore, _emberMetalDebug, _emberRuntimeMixinsMutable_array, _emberRuntimeSystemNative_array, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberMetalEvents, _emberHtmlbarsTemplatesContainerView) { 'use strict'; - _emberHtmlbarsTemplatesContainerView.default.meta.revision = 'Ember@2.3.2'; + _emberHtmlbarsTemplatesContainerView.default.meta.revision = 'Ember@2.4.0-beta.2'; /** @module ember @submodule ember-views */ @@ -46234,11 +46735,11 @@ ```html <div id="ember1" class="ember-view disabled"></div> ``` - Updates to the the value of a class name binding will result in automatic + Updates to the value of a class name binding will result in automatic update of the HTML `class` attribute in the view's rendered HTML representation. If the value becomes `false` or `undefined` the class name will be removed. Both `classNames` and `classNameBindings` are concatenated properties. See @@ -46331,11 +46832,11 @@ } }) }); ``` - Updates to the the property of an attribute binding will result in automatic + Updates to the property of an attribute binding will result in automatic update of the HTML attribute in the view's rendered HTML representation. `attributeBindings` is a concatenated property. See [Ember.Object](/api/classes/Ember.Object.html) documentation for more information about concatenated properties. @@ -46515,11 +47016,11 @@ argument to this method. ```javascript AView = Ember.View.extend({ click: function(event) { - // will be called when when an instance's + // will be called when an instance's // rendered element is clicked } }); ``` @@ -46536,11 +47037,11 @@ ```javascript AView = Ember.View.extend({ eventManager: Ember.Object.create({ doubleClick: function(event, view) { - // will be called when when an instance's + // will be called when an instance's // rendered element or any rendering // of this view's descendant // elements is clicked } }) @@ -46777,99 +47278,9 @@ exports.TemplateRenderingSupport = _emberViewsMixinsTemplate_rendering_support.default; exports.ClassNamesSupport = _emberViewsMixinsClass_names_support.default; exports.DeprecatedView = DeprecatedView; }); // for the side effect of extending Ember.run.queues -enifed('ember-views', ['exports', 'ember-runtime', 'ember-views/system/jquery', 'ember-views/system/utils', 'ember-views/system/ext', 'ember-views/views/states', 'ember-metal-views/renderer', 'ember-views/views/core_view', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-views/views/collection_view', 'ember-views/components/component', 'ember-views/system/event_dispatcher', 'ember-views/mixins/view_target_action_support', 'ember-views/component_lookup', 'ember-views/views/checkbox', 'ember-views/mixins/text_support', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/select', 'ember-views/compat/metamorph_view', 'ember-views/views/legacy_each_view'], function (exports, _emberRuntime, _emberViewsSystemJquery, _emberViewsSystemUtils, _emberViewsSystemExt, _emberViewsViewsStates, _emberMetalViewsRenderer, _emberViewsViewsCore_view, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberViewsViewsCollection_view, _emberViewsComponentsComponent, _emberViewsSystemEvent_dispatcher, _emberViewsMixinsView_target_action_support, _emberViewsComponent_lookup, _emberViewsViewsCheckbox, _emberViewsMixinsText_support, _emberViewsViewsText_field, _emberViewsViewsText_area, _emberViewsViewsSelect, _emberViewsCompatMetamorph_view, _emberViewsViewsLegacy_each_view) { - /** - @module ember - @submodule ember-views - */ - - // BEGIN IMPORTS - 'use strict'; - - // END IMPORTS - - /** - Alias for jQuery - - @method $ - @for Ember - @public - */ - - // BEGIN EXPORTS - _emberRuntime.default.$ = _emberViewsSystemJquery.default; - - _emberRuntime.default.ViewTargetActionSupport = _emberViewsMixinsView_target_action_support.default; - - var ViewUtils = _emberRuntime.default.ViewUtils = {}; - ViewUtils.isSimpleClick = _emberViewsSystemUtils.isSimpleClick; - ViewUtils.getViewClientRects = _emberViewsSystemUtils.getViewClientRects; - ViewUtils.getViewBoundingClientRect = _emberViewsSystemUtils.getViewBoundingClientRect; - - if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - _emberRuntime.default.CoreView = _emberViewsViewsCore_view.DeprecatedCoreView; - _emberRuntime.default.View = _emberViewsViewsView.DeprecatedView; - _emberRuntime.default.View.states = _emberViewsViewsStates.states; - _emberRuntime.default.View.cloneStates = _emberViewsViewsStates.cloneStates; - _emberRuntime.default.View._Renderer = _emberMetalViewsRenderer.default; - _emberRuntime.default.ContainerView = _emberViewsViewsContainer_view.DeprecatedContainerView; - _emberRuntime.default.CollectionView = _emberViewsViewsCollection_view.default; - } - - _emberRuntime.default._Renderer = _emberMetalViewsRenderer.default; - - _emberRuntime.default.Checkbox = _emberViewsViewsCheckbox.default; - _emberRuntime.default.TextField = _emberViewsViewsText_field.default; - _emberRuntime.default.TextArea = _emberViewsViewsText_area.default; - - if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - _emberRuntime.default.Select = _emberViewsViewsSelect.Select; - } - - _emberRuntime.default.SelectOption = _emberViewsViewsSelect.SelectOption; - _emberRuntime.default.SelectOptgroup = _emberViewsViewsSelect.SelectOptgroup; - - _emberRuntime.default.TextSupport = _emberViewsMixinsText_support.default; - _emberRuntime.default.ComponentLookup = _emberViewsComponent_lookup.default; - _emberRuntime.default.Component = _emberViewsComponentsComponent.default; - _emberRuntime.default.EventDispatcher = _emberViewsSystemEvent_dispatcher.default; - - // Deprecated: - if (_emberRuntime.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) { - _emberRuntime.default._Metamorph = _emberViewsCompatMetamorph_view._Metamorph; - _emberRuntime.default._MetamorphView = _emberViewsCompatMetamorph_view.default; - _emberRuntime.default._LegacyEachView = _emberViewsViewsLegacy_each_view.default; - } - - // END EXPORTS - - exports.default = _emberRuntime.default; -}); -// for the side effect of extending Ember.run.queues -enifed('ember', ['exports', 'ember-metal', 'ember-runtime', 'ember-views', 'ember-routing', 'ember-application', 'ember-extension-support', 'ember-htmlbars', 'ember-routing-htmlbars', 'ember-routing-views', 'ember-metal/core', 'ember-runtime/system/lazy_load'], function (exports, _emberMetal, _emberRuntime, _emberViews, _emberRouting, _emberApplication, _emberExtensionSupport, _emberHtmlbars, _emberRoutingHtmlbars, _emberRoutingViews, _emberMetalCore, _emberRuntimeSystemLazy_load) { - // require the main entry points for each of these packages - // this is so that the global exports occur properly - 'use strict'; - - if (_emberMetalCore.default.__loader.registry['ember-template-compiler']) { - requireModule('ember-template-compiler'); - } - - // do this to ensure that Ember.Test is defined properly on the global - // if it is present. - if (_emberMetalCore.default.__loader.registry['ember-testing']) { - requireModule('ember-testing'); - } - - _emberRuntimeSystemLazy_load.runLoadHooks('Ember'); - - /** - @module ember - */ -}); enifed('htmlbars-runtime/expression-visitor', ['exports'], function (exports) { /** # Expression Nodes: These nodes are not directly responsible for any part of the DOM, but are