{{analysisForPhase.phase}} {{#if analysisForPhase.isSignificant}} {{#if (isFaster analysisForPhase)}} ({{abs analysisForPhase.hlDiff}} ms faster) {{else}} ({{abs analysisForPhase.hlDiff}} ms slower) {{/if}} {{else}} (No/Borderline Difference) {{/if}}
Based on the P-value of this benchmark the evidence for a metric shift is {{#if (getQuality analysisForPhase.pValue 0.1)}} {{#if (getQuality analysisForPhase.pValue 0.05)}} very strong. {{else}} strong. {{/if}} {{else}} weak. {{/if}} TracerBench has determined the {{#if analysisForPhase.isSignificant}} results are significant meaning they are worth looking at. {{else}} results are not significant. {{/if}} {{#if analysisForPhase.isSignificant}} A statistics estimator (Hodges–Lehmann estimator) was used to determine "{{analysisForPhase.servers.[1].name}}" is {{#if (isFaster analysisForPhase)}} faster {{else}} slower {{/if}} by {{abs analysisForPhase.hlDiff}} ms. TracerBench is 95% confident "{{analysisForPhase.servers.[1].name}}" is {{#if (isFaster analysisForPhase)}} faster {{else}} slower {{/if}} between {{absSort analysisForPhase.ciMax analysisForPhase.ciMin 0}} ms to {{absSort analysisForPhase.ciMax analysisForPhase.ciMin 1}} ms based on {{analysisForPhase.sampleCount}} samples using a (confidence interval). {{/if}}
Boxplot & Frequency Results
{{reportTitles.plotTitle}} on {{reportTitles.browserVersion}}
Cumulative sub-phases of duration
The chart below shows the finish times (a point in the page load duration) of the sub-phases for experiment and control. It gives a high level view on what changed (if any).
You can view more details about the sub-phases in the section below "Isolated sub-phases of duration".
Isolated sub-phases of duration
Configs Used
{{configsSJSONString}}
{{format-currency cents currency="$"}}
```
Additionally a helper can be called as a nested helper (sometimes called a
subexpression). In this example, the computed value of a helper is passed
to a component named `show-money`:
```handlebars
{{show-money amount=(format-currency cents currency="$")}}
```
Helpers defined using a class must provide a `compute` function. For example:
```app/helpers/format-currency.js
import Helper from '@ember/component/helper';
export default Helper.extend({
compute([cents], { currency }) {
return `${currency}${cents * 0.01}`;
}
});
```
Each time the input to a helper changes, the `compute` function will be
called again.
As instances, these helpers also have access to the container and will accept
injected dependencies.
Additionally, class helpers can call `recompute` to force a new computation.
@class Helper
@public
@since 1.13.0
*/
let Helper = _runtime2.FrameworkObject.extend({
init() {
this._super(...arguments);
this[RECOMPUTE_TAG] = _reference.DirtyableTag.create();
},
/**
On a class-based helper, it may be useful to force a recomputation of that
helpers value. This is akin to `rerender` on a component.
For example, this component will rerender when the `currentUser` on a
session service changes:
```app/helpers/current-user-email.js
import Helper from '@ember/component/helper'
import { inject as service } from '@ember/service'
import { observer } from '@ember/object'
export default Helper.extend({
session: service(),
onNewUser: observer('session.currentUser', function() {
this.recompute();
}),
compute() {
return this.get('session.currentUser.email');
}
});
```
@method recompute
@public
@since 1.13.0
*/
recompute() {
this[RECOMPUTE_TAG].inner.dirty();
}
});
Helper.isHelperFactory = true;
class Wrapper {
constructor(compute) {
this.compute = compute;
this.isHelperFactory = true;
}
create() {
// needs new instance or will leak containers
return {
compute: this.compute
};
}
}
/**
In many cases, the ceremony of a full `Helper` class is not required.
The `helper` method create pure-function helpers without instances. For
example:
```app/helpers/format-currency.js
import { helper } from '@ember/component/helper';
export default helper(function(params, hash) {
let cents = params[0];
let currency = hash.currency;
return `${currency}${cents * 0.01}`;
});
```
@static
@param {Function} helper The helper function
@method helper
@for @ember/component/helper
@public
@since 1.13.0
*/
function helper(helperFn) {
return new Wrapper(helperFn);
}
function toBool(predicate) {
if ((0, _runtime2.isArray)(predicate)) {
return predicate.length !== 0;
} else {
return !!predicate;
}
}
const UPDATE = (0, _utils.symbol)('UPDATE');
const INVOKE = (0, _utils.symbol)('INVOKE');
const ACTION = (0, _utils.symbol)('ACTION');
let maybeFreeze;
if (false /* DEBUG */) {
// gaurding this in a DEBUG gaurd (as well as all invocations)
// so that it is properly stripped during the minification's
// dead code elimination
maybeFreeze = obj => {
// re-freezing an already frozen object introduces a significant
// performance penalty on Chrome (tested through 59).
//
// See: https://bugs.chromium.org/p/v8/issues/detail?id=6450
if (!Object.isFrozen(obj)) {
Object.freeze(obj);
}
};
}
class EmberPathReference {
get(key) {
return PropertyReference.create(this, key);
}
}
class CachedReference$1 extends EmberPathReference {
constructor() {
super();
this._lastRevision = null;
this._lastValue = null;
}
value() {
let { tag, _lastRevision, _lastValue } = this;
if (_lastRevision === null || !tag.validate(_lastRevision)) {
_lastValue = this._lastValue = this.compute();
this._lastRevision = tag.value();
}
return _lastValue;
}
}
class RootReference extends _reference.ConstReference {
constructor(value) {
super(value);
this.children = Object.create(null);
}
get(propertyKey) {
let ref = this.children[propertyKey];
if (ref === undefined) {
ref = this.children[propertyKey] = new RootPropertyReference(this.inner, propertyKey);
}
return ref;
}
}
let TwoWayFlushDetectionTag;
if (false /* DEBUG */) {
TwoWayFlushDetectionTag = class {
static create(tag, key, ref) {
return new _reference.TagWrapper(tag.type, new TwoWayFlushDetectionTag(tag, key, ref));
}
constructor(tag, key, ref) {
this.tag = tag;
this.parent = null;
this.key = key;
this.ref = ref;
}
value() {
return this.tag.value();
}
validate(ticket) {
let { parent, key } = this;
let isValid = this.tag.validate(ticket);
if (isValid && parent) {
(0, _metal.didRender)(parent, key, this.ref);
}
return isValid;
}
didCompute(parent) {
this.parent = parent;
(0, _metal.didRender)(parent, this.key, this.ref);
}
};
}
class PropertyReference extends CachedReference$1 {
static create(parentReference, propertyKey) {
if ((0, _reference.isConst)(parentReference)) {
return new RootPropertyReference(parentReference.value(), propertyKey);
} else {
return new NestedPropertyReference(parentReference, propertyKey);
}
}
get(key) {
return new NestedPropertyReference(this, key);
}
}
class RootPropertyReference extends PropertyReference {
constructor(parentValue, propertyKey) {
super();
this._parentValue = parentValue;
this._propertyKey = propertyKey;
if (false /* DEBUG */) {
this.tag = TwoWayFlushDetectionTag.create((0, _metal.tagForProperty)(parentValue, propertyKey), propertyKey, this);
} else {
this.tag = (0, _metal.tagForProperty)(parentValue, propertyKey);
}
if (false /* DEBUG */) {
(0, _metal.watchKey)(parentValue, propertyKey);
}
}
compute() {
let { _parentValue, _propertyKey } = this;
if (false /* DEBUG */) {
this.tag.inner.didCompute(_parentValue);
}
return (0, _metal.get)(_parentValue, _propertyKey);
}
[UPDATE](value) {
(0, _metal.set)(this._parentValue, this._propertyKey, value);
}
}
class NestedPropertyReference extends PropertyReference {
constructor(parentReference, propertyKey) {
super();
let parentReferenceTag = parentReference.tag;
let parentObjectTag = _reference.UpdatableTag.create(_reference.CONSTANT_TAG);
this._parentReference = parentReference;
this._parentObjectTag = parentObjectTag;
this._propertyKey = propertyKey;
if (false /* DEBUG */) {
let tag = (0, _reference.combine)([parentReferenceTag, parentObjectTag]);
this.tag = TwoWayFlushDetectionTag.create(tag, propertyKey, this);
} else {
this.tag = (0, _reference.combine)([parentReferenceTag, parentObjectTag]);
}
}
compute() {
let { _parentReference, _parentObjectTag, _propertyKey } = this;
let parentValue = _parentReference.value();
_parentObjectTag.inner.update((0, _metal.tagForProperty)(parentValue, _propertyKey));
let parentValueType = typeof parentValue;
if (parentValueType === 'string' && _propertyKey === 'length') {
return parentValue.length;
}
if (parentValueType === 'object' && parentValue !== null || parentValueType === 'function') {
if (false /* DEBUG */) {
(0, _metal.watchKey)(parentValue, _propertyKey);
}
if (false /* DEBUG */) {
this.tag.inner.didCompute(parentValue);
}
return (0, _metal.get)(parentValue, _propertyKey);
} else {
return undefined;
}
}
[UPDATE](value) {
let parent = this._parentReference.value();
(0, _metal.set)(parent, this._propertyKey, value);
}
}
class UpdatableReference extends EmberPathReference {
constructor(value) {
super();
this.tag = _reference.DirtyableTag.create();
this._value = value;
}
value() {
return this._value;
}
update(value) {
let { _value } = this;
if (value !== _value) {
this.tag.inner.dirty();
this._value = value;
}
}
}
class ConditionalReference$1 extends _runtime.ConditionalReference {
static create(reference) {
if ((0, _reference.isConst)(reference)) {
let value = reference.value();
if ((0, _utils.isProxy)(value)) {
return new RootPropertyReference(value, 'isTruthy');
} else {
return _runtime.PrimitiveReference.create(toBool(value));
}
}
return new ConditionalReference$1(reference);
}
constructor(reference) {
super(reference);
this.objectTag = _reference.UpdatableTag.create(_reference.CONSTANT_TAG);
this.tag = (0, _reference.combine)([reference.tag, this.objectTag]);
}
toBool(predicate) {
if ((0, _utils.isProxy)(predicate)) {
this.objectTag.inner.update((0, _metal.tagForProperty)(predicate, 'isTruthy'));
return (0, _metal.get)(predicate, 'isTruthy');
} else {
this.objectTag.inner.update((0, _metal.tagFor)(predicate));
return toBool(predicate);
}
}
}
class SimpleHelperReference extends CachedReference$1 {
static create(helper$$1, args) {
if ((0, _reference.isConst)(args)) {
let { positional, named } = args;
let positionalValue = positional.value();
let namedValue = named.value();
if (false /* DEBUG */) {
maybeFreeze(positionalValue);
maybeFreeze(namedValue);
}
let result = helper$$1(positionalValue, namedValue);
return valueToRef(result);
} else {
return new SimpleHelperReference(helper$$1, args);
}
}
constructor(helper$$1, args) {
super();
this.tag = args.tag;
this.helper = helper$$1;
this.args = args;
}
compute() {
let { helper: helper$$1, args: { positional, named } } = this;
let positionalValue = positional.value();
let namedValue = named.value();
if (false /* DEBUG */) {
maybeFreeze(positionalValue);
maybeFreeze(namedValue);
}
return helper$$1(positionalValue, namedValue);
}
}
class ClassBasedHelperReference extends CachedReference$1 {
static create(instance, args) {
return new ClassBasedHelperReference(instance, args);
}
constructor(instance, args) {
super();
this.tag = (0, _reference.combine)([instance[RECOMPUTE_TAG], args.tag]);
this.instance = instance;
this.args = args;
}
compute() {
let { instance, args: { positional, named } } = this;
let positionalValue = positional.value();
let namedValue = named.value();
if (false /* DEBUG */) {
maybeFreeze(positionalValue);
maybeFreeze(namedValue);
}
return instance.compute(positionalValue, namedValue);
}
}
class InternalHelperReference extends CachedReference$1 {
constructor(helper$$1, args) {
super();
this.tag = args.tag;
this.helper = helper$$1;
this.args = args;
}
compute() {
let { helper: helper$$1, args } = this;
return helper$$1(args);
}
}
class UnboundReference extends _reference.ConstReference {
static create(value) {
return valueToRef(value, false);
}
get(key) {
return valueToRef((0, _metal.get)(this.inner, key), false);
}
}
class ReadonlyReference extends CachedReference$1 {
constructor(inner) {
super();
this.inner = inner;
}
get tag() {
return this.inner.tag;
}
get [INVOKE]() {
return this.inner[INVOKE];
}
compute() {
return this.inner.value();
}
get(key) {
return this.inner.get(key);
}
}
function referenceFromParts(root, parts) {
let reference = root;
for (let i = 0; i < parts.length; i++) {
reference = reference.get(parts[i]);
}
return reference;
}
function valueToRef(value, bound = true) {
if (value !== null && typeof value === 'object') {
// root of interop with ember objects
return bound ? new RootReference(value) : new UnboundReference(value);
}
// ember doesn't do observing with functions
if (typeof value === 'function') {
return new UnboundReference(value);
}
return _runtime.PrimitiveReference.create(value);
}
const DIRTY_TAG = (0, _utils.symbol)('DIRTY_TAG');
const ARGS = (0, _utils.symbol)('ARGS');
const ROOT_REF = (0, _utils.symbol)('ROOT_REF');
const IS_DISPATCHING_ATTRS = (0, _utils.symbol)('IS_DISPATCHING_ATTRS');
const HAS_BLOCK = (0, _utils.symbol)('HAS_BLOCK');
const BOUNDS = (0, _utils.symbol)('BOUNDS');
/**
@module @ember/component
*/
/**
A `Component` is a view that is completely
isolated. Properties accessed in its templates go
to the view object and actions are targeted at
the view object. There is no access to the
surrounding context or outer controller; all
contextual information must be passed in.
The easiest way to create a `Component` is via
a template. If you name a template
`app/templates/components/my-foo.hbs`, you will be able to use
`{{my-foo}}` in other templates, which will make
an instance of the isolated component.
```app/templates/components/my-foo.hbs
{{person-profile person=currentUser}}
```
```app/templates/components/person-profile.hbs
{{person.title}}
{{person.signature}}
``` You can use `yield` inside a template to include the **contents** of any block attached to the component. The block will be executed in the context of the surrounding context or outer controller: ```handlebars {{#person-profile person=currentUser}}Admin mode
{{! Executed in the controller's context. }} {{/person-profile}} ``` ```app/templates/components/person-profile.hbs{{person.title}}
{{! Executed in the component's context. }} {{yield}} {{! block contents }} ``` If you want to customize the component, in order to handle events or actions, you implement a subclass of `Component` named after the name of the component. For example, you could implement the action `hello` for the `person-profile` component: ```app/components/person-profile.js import Component from '@ember/component'; export default Component.extend({ actions: { hello(name) { console.log("Hello", name); } } }); ``` And then use it in the component's template: ```app/templates/components/person-profile.hbs{{person.title}}
{{yield}} ``` Components must have a `-` in their name to avoid conflicts with built-in controls that wrap HTML elements. This is consistent with the same requirement in web components. ## HTML Tag The default HTML tag name used for a component's DOM representation is `div`. This can be customized by setting the `tagName` property. The following component class: ```app/components/emphasized-paragraph.js import Component from '@ember/component'; export default Component.extend({ tagName: 'em' }); ``` Would result in instances with the following HTML: ```html ``` ## HTML `class` Attribute The HTML `class` attribute of a component's tag can be set by providing a `classNames` property that is set to an array of strings: ```app/components/my-widget.js import Component from '@ember/component'; export default Component.extend({ classNames: ['my-class', 'my-other-class'] }); ``` Will result in component instances with an HTML representation of: ```html ``` `class` attribute values can also be set by providing a `classNameBindings` property set to an array of properties names for the component. The return value of these properties will be added as part of the value for the components's `class` attribute. These properties can be computed properties: ```app/components/my-widget.js import Component from '@ember/component'; import { computed } from '@ember/object'; export default Component.extend({ classNameBindings: ['propertyA', 'propertyB'], propertyA: 'from-a', propertyB: computed(function() { if (someLogic) { return 'from-b'; } }) }); ``` Will result in component instances with an HTML representation of: ```html ``` If the value of a class name binding returns a boolean the property name itself will be used as the class name if the property is true. The class name will not be added if the value is `false` or `undefined`. ```app/components/my-widget.js import Component from '@ember/component'; export default Component.extend({ classNameBindings: ['hovered'], hovered: true }); ``` Will result in component instances with an HTML representation of: ```html ``` When using boolean class name bindings you can supply a string value other than the property name for use as the `class` HTML attribute by appending the preferred value after a ":" character when defining the binding: ```app/components/my-widget.js import Component from '@ember/component'; export default Component.extend({ classNameBindings: ['awesome:so-very-cool'], awesome: true }); ``` Will result in component instances with an HTML representation of: ```html ``` Boolean value class name bindings whose property names are in a camelCase-style format will be converted to a dasherized format: ```app/components/my-widget.js import Component from '@ember/component'; export default Component.extend({ classNameBindings: ['isUrgent'], isUrgent: true }); ``` Will result in component instances with an HTML representation of: ```html ``` Class name bindings can also refer to object values that are found by traversing a path relative to the component itself: ```app/components/my-widget.js import Component from '@ember/component'; import EmberObject from '@ember/object'; export default Component.extend({ classNameBindings: ['messages.empty'], messages: EmberObject.create({ empty: true }) }); ``` Will result in component instances with an HTML representation of: ```html ``` If you want to add a class name for a property which evaluates to true and and a different class name if it evaluates to false, you can pass a binding like this: ```app/components/my-widget.js import Component from '@ember/component'; export default Component.extend({ classNameBindings: ['isEnabled:enabled:disabled'], isEnabled: true }); ``` Will result in component instances with an HTML representation of: ```html ``` When isEnabled is `false`, the resulting HTML representation looks like this: ```html ``` This syntax offers the convenience to add a class if a property is `false`: ```app/components/my-widget.js import Component from '@ember/component'; // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false export default Component.extend({ classNameBindings: ['isEnabled::disabled'], isEnabled: true }); ``` Will result in component instances with an HTML representation of: ```html ``` When the `isEnabled` property on the component is set to `false`, it will result in component instances with an HTML representation of: ```html ``` Updates to the value of a class name binding will result in automatic update of the HTML `class` attribute in the component'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 [EmberObject](/api/ember/release/classes/EmberObject) documentation for more information about concatenated properties. ## HTML Attributes The HTML attribute section of a component's tag can be set by providing an `attributeBindings` property set to an array of property names on the component. The return value of these properties will be used as the value of the component's HTML associated attribute: ```app/components/my-anchor.js import Component from '@ember/component'; export default Component.extend({ tagName: 'a', attributeBindings: ['href'], href: 'http://google.com' }); ``` Will result in component instances with an HTML representation of: ```html ``` One property can be mapped on to another by placing a ":" between the source property and the destination property: ```app/components/my-anchor.js import Component from '@ember/component'; export default Component.extend({ tagName: 'a', attributeBindings: ['url:href'], url: 'http://google.com' }); ``` Will result in component instances with an HTML representation of: ```html ``` Namespaced attributes (e.g. `xlink:href`) are supported, but have to be mapped, since `:` is not a valid character for properties in Javascript: ```app/components/my-use.js import Component from '@ember/component'; export default Component.extend({ tagName: 'use', attributeBindings: ['xlinkHref:xlink:href'], xlinkHref: '#triangle' }); ``` Will result in component instances with an HTML representation of: ```html ``` If the return value of an `attributeBindings` monitored property is a boolean the attribute will be present or absent depending on the value: ```app/components/my-text-input.js import Component from '@ember/component'; export default Component.extend({ tagName: 'input', attributeBindings: ['disabled'], disabled: false }); ``` Will result in a component instance with an HTML representation of: ```html ``` `attributeBindings` can refer to computed properties: ```app/components/my-text-input.js import Component from '@ember/component'; import { computed } from '@ember/object'; export default Component.extend({ tagName: 'input', attributeBindings: ['disabled'], disabled: computed(function() { if (someLogic) { return true; } else { return false; } }) }); ``` To prevent setting an attribute altogether, use `null` or `undefined` as the return value of the `attributeBindings` monitored property: ```app/components/my-text-input.js import Component from '@ember/component'; export default Component.extend({ tagName: 'form', attributeBindings: ['novalidate'], novalidate: null }); ``` Updates to the property of an attribute binding will result in automatic update of the HTML attribute in the component's rendered HTML representation. `attributeBindings` is a concatenated property. See [EmberObject](/api/ember/release/classes/EmberObject) documentation for more information about concatenated properties. ## Layouts See [Ember.Templates.helpers.yield](/api/ember/release/classes/Ember.Templates.helpers/methods/yield?anchor=yield) for more information. Layout can be used to wrap content in a component. In addition to wrapping content in a Component's template, you can also use the public layout API in your Component JavaScript. ```app/templates/components/person-profile.hbsPerson's Title
{{yield}}
```
```app/components/person-profile.js
import Component from '@ember/component';
import layout from '../templates/components/person-profile';
export default Component.extend({
layout
});
```
If you call the `person-profile` component like so:
```
{{#person-profile}}
Chief Basket Weaver
Fisherman Industries
{{/person-profile}} It will result in the following HTML output: ```htmlPerson's Title
Chief Basket Weaver
Fisherman Industries
{{outputWrittenWords}}
```
Would result in the following HTML:
```html
<-- the following div will be updated in real time as you type -->
Lots of text that IS bound
```
Finally, this example really shows the power and ease of Ember when two
properties are bound to eachother via `alias`. Type into
either text area box and they'll both stay in sync. Note that
`alias` costs more in terms of performance, so only use it when
your really binding in both directions:
```app/controllers/application.js
import Controller from '@ember/controller';
import { alias } from '@ember/object/computed';
export default Controller.extend({
writtenWords: "Lots of text that IS bound",
twoWayWrittenWords: alias("writtenWords")
});
```
```handlebars
{{textarea value=writtenWords}}
{{textarea value=twoWayWrittenWords}}
```
```html
<-- both updated in real time -->
```
### Actions
The helper can send multiple actions based on user events.
The action property defines the action which is send when
the user presses the return key.
```handlebars
{{input action="submit"}}
```
The helper allows some user events to send actions.
* `enter`
* `insert-newline`
* `escape-press`
* `focus-in`
* `focus-out`
* `key-press`
For example, if you desire an action to be sent when the input is blurred,
you only need to setup the action name to the event name property.
```handlebars
{{textarea focus-out="alertMessage"}}
```
See more about [Text Support Actions](/api/ember/release/classes/TextArea)
### Extension
Internally, `{{textarea}}` creates an instance of `TextArea`, passing
arguments from the helper to `TextArea`'s `create` method. You can
extend the capabilities of text areas in your application by reopening this
class. For example, if you are building a Bootstrap project where `data-*`
attributes are used, you can globally add support for a `data-*` attribute
on all `{{textarea}}`s' in your app by reopening `TextArea` or
`TextSupport` and adding it to the `attributeBindings` concatenated
property:
```javascript
import TextArea from '@ember/component/text-area';
TextArea.reopen({
attributeBindings: ['data-error']
});
```
Keep in mind when writing `TextArea` subclasses that `TextArea`
itself extends `Component`. Expect isolated component semantics, not
legacy 1.x view semantics (like `controller` being present).
See more about [Ember components](/api/ember/release/classes/Component)
@method textarea
@for Ember.Templates.helpers
@param {Hash} options
@public
*/
/**
The internal class used to create textarea element when the `{{textarea}}`
helper is used.
See [Ember.Templates.helpers.textarea](/api/ember/release/classes/Ember.Templates.helpers/methods/textarea?anchor=textarea) for usage details.
## Layout and LayoutName properties
Because HTML `textarea` elements do not contain inner HTML the `layout` and
`layoutName` properties will not be applied.
@class TextArea
@extends Component
@uses Ember.TextSupport
@public
*/
const TextArea = Component.extend(_views.TextSupport, {
classNames: ['ember-text-area'],
layout,
tagName: 'textarea',
attributeBindings: ['rows', 'cols', 'name', 'selectionEnd', 'selectionStart', 'autocomplete', 'wrap', 'lang', 'dir', 'value'],
rows: null,
cols: null
});
TextArea.toString = () => '@ember/component/text-area';
var layout$1 = template({ "id": "r9g6x1y/", "block": "{\"symbols\":[\"&default\"],\"statements\":[[4,\"if\",[[23,[\"linkTitle\"]]],null,{\"statements\":[[1,[21,\"linkTitle\"],false]],\"parameters\":[]},{\"statements\":[[14,1]],\"parameters\":[]}]],\"hasEval\":false}", "meta": { "moduleName": "packages/@ember/-internals/glimmer/lib/templates/link-to.hbs" } });
/**
@module ember
*/
/**
@module @ember/routing
*/
/**
`LinkComponent` renders an element whose `click` event triggers a
transition of the application's instance of `Router` to
a supplied route by name.
`LinkComponent` components are invoked with {{#link-to}}. Properties
of this class can be overridden with `reopen` to customize application-wide
behavior.
@class LinkComponent
@extends Component
@see {Ember.Templates.helpers.link-to}
@public
**/
const LinkComponent = Component.extend({
layout: layout$1,
tagName: 'a',
/**
Used to determine when this `LinkComponent` is active.
@property current-when
@public
*/
'current-when': null,
/**
Sets the `title` attribute of the `LinkComponent`'s HTML element.
@property title
@default null
@public
**/
title: null,
/**
Sets the `rel` attribute of the `LinkComponent`'s HTML element.
@property rel
@default null
@public
**/
rel: null,
/**
Sets the `tabindex` attribute of the `LinkComponent`'s HTML element.
@property tabindex
@default null
@public
**/
tabindex: null,
/**
Sets the `target` attribute of the `LinkComponent`'s HTML element.
@since 1.8.0
@property target
@default null
@public
**/
target: null,
/**
The CSS class to apply to `LinkComponent`'s element when its `active`
property is `true`.
@property activeClass
@type String
@default active
@public
**/
activeClass: 'active',
/**
The CSS class to apply to `LinkComponent`'s element when its `loading`
property is `true`.
@property loadingClass
@type String
@default loading
@private
**/
loadingClass: 'loading',
/**
The CSS class to apply to a `LinkComponent`'s element when its `disabled`
property is `true`.
@property disabledClass
@type String
@default disabled
@private
**/
disabledClass: 'disabled',
/**
Determines whether the `LinkComponent` will trigger routing via
the `replaceWith` routing strategy.
@property replace
@type Boolean
@default false
@public
**/
replace: false,
/**
By default the `{{link-to}}` component will bind to the `href` and
`title` attributes. It's discouraged that you override these defaults,
however you can push onto the array if needed.
@property attributeBindings
@type Array | String
@default ['title', 'rel', 'tabindex', 'target']
@public
*/
attributeBindings: ['href', 'title', 'rel', 'tabindex', 'target'],
/**
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', 'ember-transitioning-in', 'ember-transitioning-out']
@public
*/
classNameBindings: ['active', 'loading', 'disabled', 'transitioningIn', 'transitioningOut'],
/**
By default the `{{link-to}}` component responds to the `click` event. You
can override this globally by setting this property to your custom
event name.
This is particularly useful on mobile when one wants to avoid the 300ms
click delay using some sort of custom `tap` event.
@property eventName
@type String
@default click
@private
*/
eventName: 'click',
// this is doc'ed here so it shows up in the events
// section of the API documentation, which is where
// people will likely go looking for it.
/**
Triggers the `LinkComponent`'s routing behavior. If
`eventName` is changed to a value other than `click`
the routing behavior will trigger on that custom event
instead.
@event click
@private
*/
/**
An overridable method called when `LinkComponent` objects are instantiated.
Example:
```app/components/my-link.js
import LinkComponent from '@ember/routing/link-component';
export default LinkComponent.extend({
init() {
this._super(...arguments);
console.log('Event is ' + this.get('eventName'));
}
});
```
NOTE: If you do override `init` for a framework class like `Component`,
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
*/
init() {
this._super(...arguments);
// Map desired event name to invoke function
let eventName = (0, _metal.get)(this, 'eventName');
this.on(eventName, this, this._invoke);
},
_routing: (0, _service.inject)('-routing'),
/**
Accessed as a classname binding to apply the `LinkComponent`'s `disabledClass`
CSS `class` to the element when the link is disabled.
When `true` interactions with the element will not trigger route changes.
@property disabled
@private
*/
disabled: (0, _metal.computed)({
get(_key) {
// always returns false for `get` because (due to the `set` just below)
// the cached return value from the set will prevent this getter from _ever_
// being called after a set has occured
return false;
},
set(_key, value) {
this._isDisabled = value;
return value ? (0, _metal.get)(this, 'disabledClass') : false;
}
}),
_isActive(routerState) {
if ((0, _metal.get)(this, 'loading')) {
return false;
}
let currentWhen = (0, _metal.get)(this, 'current-when');
if (typeof currentWhen === 'boolean') {
return currentWhen;
}
let isCurrentWhenSpecified = !!currentWhen;
currentWhen = currentWhen || (0, _metal.get)(this, 'qualifiedRouteName');
currentWhen = currentWhen.split(' ');
let routing = (0, _metal.get)(this, '_routing');
let models = (0, _metal.get)(this, 'models');
let resolvedQueryParams = (0, _metal.get)(this, 'resolvedQueryParams');
for (let i = 0; i < currentWhen.length; i++) {
if (routing.isActiveForRoute(models, resolvedQueryParams, currentWhen[i], routerState, isCurrentWhenSpecified)) {
return true;
}
}
return false;
},
/**
Accessed as a classname binding to apply the `LinkComponent`'s `activeClass`
CSS `class` to the element when the link is active.
A `LinkComponent` is considered active when its `currentWhen` property is `true`
or the application's current route is the route the `LinkComponent` would trigger
transitions into.
The `currentWhen` property can match against multiple routes by separating
route names using the ` ` (space) character.
@property active
@private
*/
active: (0, _metal.computed)('activeClass', '_active', function computeLinkToComponentActiveClass() {
return this.get('_active') ? (0, _metal.get)(this, 'activeClass') : false;
}),
_active: (0, _metal.computed)('_routing.currentState', 'attrs.params', function computeLinkToComponentActive() {
let currentState = (0, _metal.get)(this, '_routing.currentState');
if (!currentState) {
return false;
}
return this._isActive(currentState);
}),
willBeActive: (0, _metal.computed)('_routing.targetState', function computeLinkToComponentWillBeActive() {
let routing = (0, _metal.get)(this, '_routing');
let targetState = (0, _metal.get)(routing, 'targetState');
if ((0, _metal.get)(routing, 'currentState') === targetState) {
return;
}
return this._isActive(targetState);
}),
transitioningIn: (0, _metal.computed)('active', 'willBeActive', function computeLinkToComponentTransitioningIn() {
if ((0, _metal.get)(this, 'willBeActive') === true && !(0, _metal.get)(this, '_active')) {
return 'ember-transitioning-in';
} else {
return false;
}
}),
transitioningOut: (0, _metal.computed)('active', 'willBeActive', function computeLinkToComponentTransitioningOut() {
if ((0, _metal.get)(this, 'willBeActive') === false && (0, _metal.get)(this, '_active')) {
return 'ember-transitioning-out';
} else {
return false;
}
}),
/**
Event handler that invokes the link, activating the associated route.
@method _invoke
@param {Event} event
@private
*/
_invoke(event) {
if (!(0, _views.isSimpleClick)(event)) {
return true;
}
let preventDefault = (0, _metal.get)(this, 'preventDefault');
let targetAttribute = (0, _metal.get)(this, 'target');
if (preventDefault !== false && (!targetAttribute || targetAttribute === '_self')) {
event.preventDefault();
}
if ((0, _metal.get)(this, 'bubbles') === false) {
event.stopPropagation();
}
if (this._isDisabled) {
return false;
}
if ((0, _metal.get)(this, 'loading')) {
// eslint:disable-next-line:max-line-length
false && (0, _debug.warn)('This link-to is in an inactive loading state because at least one of its parameters presently has a null/undefined value, or the provided route name is invalid.', false, {
id: 'ember-glimmer.link-to.inactive-loading-state'
});
return false;
}
if (targetAttribute && targetAttribute !== '_self') {
return false;
}
let qualifiedRouteName = (0, _metal.get)(this, 'qualifiedRouteName');
let models = (0, _metal.get)(this, 'models');
let queryParams = (0, _metal.get)(this, 'queryParams.values');
let shouldReplace = (0, _metal.get)(this, 'replace');
let payload = {
queryParams,
routeName: qualifiedRouteName
};
// eslint:disable-next-line:max-line-length
(0, _instrumentation.flaggedInstrument)('interaction.link-to', payload, this._generateTransition(payload, qualifiedRouteName, models, queryParams, shouldReplace));
return false;
},
_generateTransition(payload, qualifiedRouteName, models, queryParams, shouldReplace) {
let routing = (0, _metal.get)(this, '_routing');
return () => {
payload.transition = routing.transitionTo(qualifiedRouteName, models, queryParams, shouldReplace);
};
},
queryParams: null,
qualifiedRouteName: (0, _metal.computed)('targetRouteName', '_routing.currentState', function computeLinkToComponentQualifiedRouteName() {
let params = (0, _metal.get)(this, 'params');
let paramsLength = params.length;
let lastParam = params[paramsLength - 1];
if (lastParam && lastParam.isQueryParams) {
paramsLength--;
}
let onlyQueryParamsSupplied = this[HAS_BLOCK] ? paramsLength === 0 : paramsLength === 1;
if (onlyQueryParamsSupplied) {
return (0, _metal.get)(this, '_routing.currentRouteName');
}
return (0, _metal.get)(this, 'targetRouteName');
}),
resolvedQueryParams: (0, _metal.computed)('queryParams', function computeLinkToComponentResolvedQueryParams() {
let resolvedQueryParams = {};
let queryParams = (0, _metal.get)(this, 'queryParams');
if (!queryParams) {
return resolvedQueryParams;
}
let values = queryParams.values;
for (let key in values) {
if (!values.hasOwnProperty(key)) {
continue;
}
resolvedQueryParams[key] = values[key];
}
return resolvedQueryParams;
}),
/**
Sets the element's `href` attribute to the url for
the `LinkComponent`'s targeted route.
If the `LinkComponent`'s `tagName` is changed to a value other
than `a`, this property will be ignored.
@property href
@private
*/
href: (0, _metal.computed)('models', 'qualifiedRouteName', function computeLinkToComponentHref() {
if ((0, _metal.get)(this, 'tagName') !== 'a') {
return;
}
let qualifiedRouteName = (0, _metal.get)(this, 'qualifiedRouteName');
let models = (0, _metal.get)(this, 'models');
if ((0, _metal.get)(this, 'loading')) {
return (0, _metal.get)(this, 'loadingHref');
}
let routing = (0, _metal.get)(this, '_routing');
let queryParams = (0, _metal.get)(this, 'queryParams.values');
if (false /* DEBUG */) {
/*
* Unfortunately, to get decent error messages, we need to do this.
* In some future state we should be able to use a "feature flag"
* which allows us to strip this without needing to call it twice.
*
* if (isDebugBuild()) {
* // Do the useful debug thing, probably including try/catch.
* } else {
* // Do the performant thing.
* }
*/
try {
routing.generateURL(qualifiedRouteName, models, queryParams);
} catch (e) {
// eslint:disable-next-line:max-line-length
false && !false && (0, _debug.assert)('You attempted to define a `{{link-to "' + qualifiedRouteName + '"}}` but did not pass the parameters required for generating its dynamic segments. ' + e.message);
}
}
return routing.generateURL(qualifiedRouteName, models, queryParams);
}),
loading: (0, _metal.computed)('_modelsAreLoaded', 'qualifiedRouteName', function computeLinkToComponentLoading() {
let qualifiedRouteName = (0, _metal.get)(this, 'qualifiedRouteName');
let modelsAreLoaded = (0, _metal.get)(this, '_modelsAreLoaded');
if (!modelsAreLoaded || qualifiedRouteName === null || qualifiedRouteName === undefined) {
return (0, _metal.get)(this, 'loadingClass');
}
}),
_modelsAreLoaded: (0, _metal.computed)('models', function computeLinkToComponentModelsAreLoaded() {
let models = (0, _metal.get)(this, 'models');
for (let i = 0; i < models.length; i++) {
let model = models[i];
if (model === null || model === undefined) {
return false;
}
}
return true;
}),
/**
The default href value to use while a link-to is loading.
Only applies when tagName is 'a'
@property loadingHref
@type String
@default #
@private
*/
loadingHref: '#',
didReceiveAttrs() {
let queryParams;
let params = (0, _metal.get)(this, 'params');
if (params) {
// Do not mutate params in place
params = params.slice();
}
false && !(params && params.length) && (0, _debug.assert)('You must provide one or more parameters to the link-to component.', params && params.length);
let disabledWhen = (0, _metal.get)(this, 'disabledWhen');
if (disabledWhen !== undefined) {
this.set('disabled', disabledWhen);
}
// Process the positional arguments, in order.
// 1. Inline link title comes first, if present.
if (!this[HAS_BLOCK]) {
this.set('linkTitle', params.shift());
}
// 2. `targetRouteName` is now always at index 0.
this.set('targetRouteName', params[0]);
// 3. The last argument (if still remaining) is the `queryParams` object.
let lastParam = params[params.length - 1];
if (lastParam && lastParam.isQueryParams) {
queryParams = params.pop();
} else {
queryParams = { values: {} };
}
this.set('queryParams', queryParams);
// 4. Any remaining indices (excepting `targetRouteName` at 0) are `models`.
params.shift();
this.set('models', params);
}
});
LinkComponent.toString = () => '@ember/routing/link-component';
LinkComponent.reopenClass({
positionalParams: 'params'
});
// @ts-check
let DebugStack;
if (false /* DEBUG */) {
class Element {
constructor(name) {
this.name = name;
}
}
class TemplateElement extends Element {}
class EngineElement extends Element {}
// eslint:disable-next-line:no-shadowed-variable
DebugStack = class DebugStack {
constructor() {
this._stack = [];
}
push(name) {
this._stack.push(new TemplateElement(name));
}
pushEngine(name) {
this._stack.push(new EngineElement(name));
}
pop() {
let element = this._stack.pop();
if (element) {
return element.name;
}
}
peek() {
let template = this._currentTemplate();
let engine = this._currentEngine();
if (engine) {
return `"${template}" (in "${engine}")`;
} else if (template) {
return `"${template}"`;
}
}
_currentTemplate() {
return this._getCurrentByType(TemplateElement);
}
_currentEngine() {
return this._getCurrentByType(EngineElement);
}
_getCurrentByType(type) {
for (let i = this._stack.length; i >= 0; i--) {
let element = this._stack[i];
if (element instanceof type) {
return element.name;
}
}
}
};
}
var DebugStack$1 = DebugStack;
/**
@module ember
*/
/**
The `{{#each}}` helper loops over elements in a collection. It is an extension
of the base Handlebars `{{#each}}` helper.
The default behavior of `{{#each}}` is to yield its inner block once for every
item in an array passing the item as the first block parameter.
```javascript
var developers = [{ name: 'Yehuda' },{ name: 'Tom' }, { name: 'Paul' }];
```
```handlebars
{{#each developers key="name" as |person|}}
{{person.name}}
{{! `this` is whatever it was outside the #each }}
{{/each}}
```
The same rules apply to arrays of primitives.
```javascript
var developerNames = ['Yehuda', 'Tom', 'Paul']
```
```handlebars
{{#each developerNames key="@index" as |name|}}
{{name}}
{{/each}}
```
During iteration, the index of each item in the array is provided as a second block parameter.
```handlebars
-
{{#each people as |person index|}}
- Hello, {{person.name}}! You're number {{index}} in line {{/each}}
Sorry, nobody is available for this task.
{{/each}} ``` @method each @for Ember.Templates.helpers @public */ /** The `{{each-in}}` helper loops over properties on an object. For example, given a `user` object that looks like: ```javascript { "name": "Shelly Sails", "age": 42 } ``` This template would display all properties on the `user` object in a list: ```handlebars-
{{#each-in user as |key value|}}
- {{key}}: {{value}} {{/each-in}}
someString
')
```
@method htmlSafe
@for @ember/template
@static
@return {Handlebars.SafeString} A string that will not be HTML escaped by Handlebars.
@public
*/
function htmlSafe(str) {
if (str === null || str === undefined) {
str = '';
} else if (typeof str !== 'string') {
str = '' + str;
}
return new SafeString(str);
}
/**
Detects if a string was decorated using `htmlSafe`.
```javascript
import { htmlSafe, isHTMLSafe } from '@ember/string';
var plainString = 'plain string',
safeString = htmlSafe('someValue
');
isHTMLSafe(plainString); // false
isHTMLSafe(safeString); // true
```
@method isHTMLSafe
@for @ember/template
@static
@return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
@public
*/
function isHTMLSafe(str) {
return str !== null && typeof str === 'object' && typeof str.toHTML === 'function';
}
/* globals module, URL */
let nodeURL;
let parsingNode;
function installProtocolForURL(environment) {
let protocol;
if (_browserEnvironment.hasDOM) {
protocol = browserProtocolForURL.call(environment, 'foobar:baz');
}
// Test to see if our DOM implementation parses
// and normalizes URLs.
if (protocol === 'foobar:') {
// Swap in the method that doesn't do this test now that
// we know it works.
environment.protocolForURL = browserProtocolForURL;
} else if (typeof URL === 'object') {
// URL globally provided, likely from FastBoot's sandbox
nodeURL = URL;
environment.protocolForURL = nodeProtocolForURL;
} else if (typeof _nodeModule.require === 'function') {
// Otherwise, we need to fall back to our own URL parsing.
// Global `require` is shadowed by Ember's loader so we have to use the fully
// qualified `module.require`.
// eslint:disable-next-line:no-require-imports
nodeURL = (0, _nodeModule.require)('url');
environment.protocolForURL = nodeProtocolForURL;
} else {
throw new Error('Could not find valid URL parsing mechanism for URL Sanitization');
}
}
function browserProtocolForURL(url) {
if (!parsingNode) {
parsingNode = document.createElement('a');
}
parsingNode.href = url;
return parsingNode.protocol;
}
function nodeProtocolForURL(url) {
let protocol = null;
if (typeof url === 'string') {
protocol = nodeURL.parse(url).protocol;
}
return protocol === null ? ':' : protocol;
}
class Environment$1 extends _runtime.Environment {
constructor(injections) {
super(injections);
this.inTransaction = false;
this.owner = injections[_owner.OWNER];
this.isInteractive = this.owner.lookup('-environment:main').isInteractive;
// can be removed once https://github.com/tildeio/glimmer/pull/305 lands
this.destroyedComponents = [];
installProtocolForURL(this);
if (false /* DEBUG */) {
this.debugStack = new DebugStack$1();
}
}
static create(options) {
return new this(options);
}
// this gets clobbered by installPlatformSpecificProtocolForURL
// it really should just delegate to a platform specific injection
protocolForURL(s) {
return s;
}
lookupComponent(name, meta) {
return (0, _views.lookupComponent)(meta.owner, name, meta);
}
toConditionalReference(reference) {
return ConditionalReference$1.create(reference);
}
iterableFor(ref, key) {
return iterableFor(ref, key);
}
scheduleInstallModifier(modifier, manager) {
if (this.isInteractive) {
super.scheduleInstallModifier(modifier, manager);
}
}
scheduleUpdateModifier(modifier, manager) {
if (this.isInteractive) {
super.scheduleUpdateModifier(modifier, manager);
}
}
didDestroy(destroyable) {
destroyable.destroy();
}
begin() {
this.inTransaction = true;
super.begin();
}
commit() {
let destroyedComponents = this.destroyedComponents;
this.destroyedComponents = [];
// components queued for destruction must be destroyed before firing
// `didCreate` to prevent errors when removing and adding a component
// with the same name (would throw an error when added to view registry)
for (let i = 0; i < destroyedComponents.length; i++) {
destroyedComponents[i].destroy();
}
try {
super.commit();
} finally {
this.inTransaction = false;
}
}
}
if (false /* DEBUG */) {
class StyleAttributeManager extends _runtime.SimpleDynamicAttribute {
set(dom, value, env) {
false && (0, _debug.warn)((0, _views.constructStyleDeprecationMessage)(value), (() => {
if (value === null || value === undefined || isHTMLSafe(value)) {
return true;
}
return false;
})(), { id: 'ember-htmlbars.style-xss-warning' });
super.set(dom, value, env);
}
update(value, env) {
false && (0, _debug.warn)((0, _views.constructStyleDeprecationMessage)(value), (() => {
if (value === null || value === undefined || isHTMLSafe(value)) {
return true;
}
return false;
})(), { id: 'ember-htmlbars.style-xss-warning' });
super.update(value, env);
}
}
Environment$1.prototype.attributeFor = function (element, attribute, isTrusting, namespace) {
if (attribute === 'style' && !isTrusting) {
return new StyleAttributeManager({ element, name: attribute, namespace });
}
return _runtime.Environment.prototype.attributeFor.call(this, element, attribute, isTrusting, namespace);
};
}
// implements the ComponentManager interface as defined in glimmer:
// eslint:disable-next-line:max-line-length
// https://github.com/glimmerjs/glimmer-vm/blob/v0.24.0-beta.4/packages/%40glimmer/runtime/lib/component/interfaces.ts#L21
class AbstractManager {
constructor() {
this.debugStack = undefined;
}
prepareArgs(_state, _args) {
return null;
}
didCreateElement(_component, _element, _operations) {}
// noop
// inheritors should also call `this.debugStack.pop()` to
// ensure the rerendering assertion messages are properly
// maintained
didRenderLayout(_component, _bounds) {
// noop
}
didCreate(_bucket) {}
// noop
// inheritors should also call `this._pushToDebugStack`
// to ensure the rerendering assertion messages are
// properly maintained
update(_bucket, _dynamicScope) {}
// noop
// inheritors should also call `this.debugStack.pop()` to
// ensure the rerendering assertion messages are properly
// maintained
didUpdateLayout(_bucket, _bounds) {
// noop
}
didUpdate(_bucket) {
// noop
}
}
if (false /* DEBUG */) {
AbstractManager.prototype._pushToDebugStack = function (name, environment) {
this.debugStack = environment.debugStack;
this.debugStack.push(name);
};
AbstractManager.prototype._pushEngineToDebugStack = function (name, environment) {
this.debugStack = environment.debugStack;
this.debugStack.pushEngine(name);
};
}
function instrumentationPayload(def) {
return { object: `${def.name}:${def.outlet}` };
}
const CAPABILITIES = {
dynamicLayout: false,
dynamicTag: false,
prepareArgs: false,
createArgs: false,
attributeHook: false,
elementHook: false,
createCaller: true,
dynamicScope: true,
updateHook: true,
createInstance: true
};
class OutletComponentManager extends AbstractManager {
create(environment, definition, _args, dynamicScope) {
if (false /* DEBUG */) {
this._pushToDebugStack(`template:${definition.template.referrer.moduleName}`, environment);
}
dynamicScope.outletState = definition.ref;
let controller = definition.controller;
let self = controller === undefined ? _runtime.UNDEFINED_REFERENCE : new RootReference(controller);
return {
self,
finalize: (0, _instrumentation._instrumentStart)('render.outlet', instrumentationPayload, definition)
};
}
layoutFor(_state, _component, _env) {
throw new Error('Method not implemented.');
}
getLayout({ template }, _resolver) {
// The router has already resolved the template
const layout = template.asLayout();
return {
handle: layout.compile(),
symbolTable: layout.symbolTable
};
}
getCapabilities() {
return CAPABILITIES;
}
getSelf({ self }) {
return self;
}
getTag() {
// an outlet has no hooks
return _reference.CONSTANT_TAG;
}
didRenderLayout(state) {
state.finalize();
if (false /* DEBUG */) {
this.debugStack.pop();
}
}
getDestructor() {
return null;
}
}
const OUTLET_MANAGER = new OutletComponentManager();
class OutletComponentDefinition {
constructor(state, manager = OUTLET_MANAGER) {
this.state = state;
this.manager = manager;
}
}
function createRootOutlet(outletView) {
if (_environment2.ENV._APPLICATION_TEMPLATE_WRAPPER) {
const WRAPPED_CAPABILITIES = (0, _polyfills.assign)({}, CAPABILITIES, {
dynamicTag: true,
elementHook: true
});
const WrappedOutletComponentManager = class extends OutletComponentManager {
getTagName(_component) {
return 'div';
}
getLayout(state) {
// The router has already resolved the template
const template = state.template;
const layout = template.asWrappedLayout();
return {
handle: layout.compile(),
symbolTable: layout.symbolTable
};
}
getCapabilities() {
return WRAPPED_CAPABILITIES;
}
didCreateElement(component, element, _operations) {
// to add GUID id and class
element.setAttribute('class', 'ember-view');
element.setAttribute('id', (0, _utils.guidFor)(component));
}
};
const WRAPPED_OUTLET_MANAGER = new WrappedOutletComponentManager();
return new OutletComponentDefinition(outletView.state, WRAPPED_OUTLET_MANAGER);
} else {
return new OutletComponentDefinition(outletView.state);
}
}
// eslint:disable-next-line:no-empty
function NOOP() {}
/**
@module ember
*/
/**
Represents the internal state of the component.
@class ComponentStateBucket
@private
*/
class ComponentStateBucket {
constructor(environment, component, args, finalizer, hasWrappedElement) {
this.environment = environment;
this.component = component;
this.args = args;
this.finalizer = finalizer;
this.hasWrappedElement = hasWrappedElement;
this.classRef = null;
this.classRef = null;
this.argsRevision = args === null ? 0 : args.tag.value();
}
destroy() {
let { component, environment } = this;
if (environment.isInteractive) {
component.trigger('willDestroyElement');
component.trigger('willClearRender');
}
environment.destroyedComponents.push(component);
}
finalize() {
let { finalizer } = this;
finalizer();
this.finalizer = NOOP;
}
}
function referenceForKey(component, key) {
return component[ROOT_REF].get(key);
}
function referenceForParts(component, parts) {
let isAttrs = parts[0] === 'attrs';
// TODO deprecate this
if (isAttrs) {
parts.shift();
if (parts.length === 1) {
return referenceForKey(component, parts[0]);
}
}
return referenceFromParts(component[ROOT_REF], parts);
}
// TODO we should probably do this transform at build time
function wrapComponentClassAttribute(hash) {
if (hash === null) {
return;
}
let [keys, values] = hash;
let index = keys === null ? -1 : keys.indexOf('class');
if (index !== -1) {
let value = values[index];
if (!Array.isArray(value)) {
return;
}
let [type] = value;
if (type === _wireFormat.Ops.Get || type === _wireFormat.Ops.MaybeLocal) {
let path = value[value.length - 1];
let propName = path[path.length - 1];
values[index] = [_wireFormat.Ops.Helper, '-class', [value, propName], null];
}
}
}
const AttributeBinding = {
parse(microsyntax) {
let colonIndex = microsyntax.indexOf(':');
if (colonIndex === -1) {
false && !(microsyntax !== 'class') && (0, _debug.assert)('You cannot use class as an attributeBinding, use classNameBindings instead.', microsyntax !== 'class');
return [microsyntax, microsyntax, true];
} else {
let prop = microsyntax.substring(0, colonIndex);
let attribute = microsyntax.substring(colonIndex + 1);
false && !(attribute !== 'class') && (0, _debug.assert)('You cannot use class as an attributeBinding, use classNameBindings instead.', attribute !== 'class');
return [prop, attribute, false];
}
},
install(_element, component, parsed, operations) {
let [prop, attribute, isSimple] = parsed;
if (attribute === 'id') {
let elementId = (0, _metal.get)(component, prop);
if (elementId === undefined || elementId === null) {
elementId = component.elementId;
}
elementId = _runtime.PrimitiveReference.create(elementId);
operations.setAttribute('id', elementId, true, null);
// operations.addStaticAttribute(element, 'id', elementId);
return;
}
let isPath = prop.indexOf('.') > -1;
let reference = isPath ? referenceForParts(component, prop.split('.')) : referenceForKey(component, prop);
false && !!(isSimple && isPath) && (0, _debug.assert)(`Illegal attributeBinding: '${prop}' is not a valid attribute name.`, !(isSimple && isPath));
if (attribute === 'style') {
reference = new StyleBindingReference(reference, referenceForKey(component, 'isVisible'));
}
operations.setAttribute(attribute, reference, false, null);
// operations.addDynamicAttribute(element, attribute, reference, false);
}
};
const DISPLAY_NONE = 'display: none;';
const SAFE_DISPLAY_NONE = htmlSafe(DISPLAY_NONE);
class StyleBindingReference extends _reference.CachedReference {
constructor(inner, isVisible) {
super();
this.inner = inner;
this.isVisible = isVisible;
this.tag = (0, _reference.combine)([inner.tag, isVisible.tag]);
}
compute() {
let value = this.inner.value();
let isVisible = this.isVisible.value();
if (isVisible !== false) {
return value;
} else if (!value) {
return SAFE_DISPLAY_NONE;
} else {
let style = value + ' ' + DISPLAY_NONE;
return isHTMLSafe(value) ? htmlSafe(style) : style;
}
}
}
const IsVisibleBinding = {
install(_element, component, operations) {
operations.setAttribute('style', (0, _reference.map)(referenceForKey(component, 'isVisible'), this.mapStyleValue), false, null);
// // the upstream type for addDynamicAttribute's `value` argument
// // appears to be incorrect. It is currently a ReferenceHello
```
```app/helpers/disable-bubbling.js
import { helper } from '@ember/component/helper';
export function disableBubbling([action]) {
return function(event) {
event.stopPropagation();
return action(event);
};
}
export default helper(disableBubbling);
```
If you need the default handler to trigger you should either register your
own event handler, or use event methods on your view class. See
["Responding to Browser Events"](/api/ember/release/classes/Component)
in the documentation for `Component` for more information.
### Specifying DOM event type
`{{action}}` helpers called in element space can specify an event type.
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
click me
```
See ["Event Names"](/api/ember/release/classes/Component) for a list of
acceptable DOM event names.
### Specifying whitelisted modifier keys
`{{action}}` helpers called in element space can specify modifier keys.
By default the `{{action}}` helper will ignore click events with pressed modifier
keys. You can supply an `allowedKeys` option to specify which keys should not be ignored.
```handlebars
click me
```
This way the action will fire when clicking with the alt key pressed down.
Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.
```handlebars
click me with any key pressed
```
### Specifying a Target
A `target` option can be provided to the helper to change
which object will receive the method call. This option must be a path
to an object, accessible in the current context:
```app/templates/application.hbs
click me
```
```app/controllers/application.js
import Controller from '@ember/controller';
import { inject as service } from '@ember/service';
export default Controller.extend({
someService: service()
});
```
@method action
@for Ember.Templates.helpers
@public
*/
function action(_vm, args) {
let { named, positional } = args;
let capturedArgs = positional.capture();
// The first two argument slots are reserved.
// pos[0] is the context (or `this`)
// pos[1] is the action name or function
// Anything else is an action argument.
let [context, action, ...restArgs] = capturedArgs.references;
// TODO: Is there a better way of doing this?
let debugKey = action._propertyKey;
let target = named.has('target') ? named.get('target') : context;
let processArgs = makeArgsProcessor(named.has('value') && named.get('value'), restArgs);
let fn;
if (typeof action[INVOKE] === 'function') {
fn = makeClosureAction(action, action, action[INVOKE], processArgs, debugKey);
} else if ((0, _reference.isConst)(target) && (0, _reference.isConst)(action)) {
fn = makeClosureAction(context.value(), target.value(), action.value(), processArgs, debugKey);
} else {
fn = makeDynamicClosureAction(context.value(), target, action, processArgs, debugKey);
}
fn[ACTION] = true;
return new UnboundReference(fn);
}
function NOOP$1(args) {
return args;
}
function makeArgsProcessor(valuePathRef, actionArgsRef) {
let mergeArgs;
if (actionArgsRef.length > 0) {
mergeArgs = args => {
return actionArgsRef.map(ref => ref.value()).concat(args);
};
}
let readValue;
if (valuePathRef) {
readValue = args => {
let valuePath = valuePathRef.value();
if (valuePath && args.length > 0) {
args[0] = (0, _metal.get)(args[0], valuePath);
}
return args;
};
}
if (mergeArgs && readValue) {
return args => {
return readValue(mergeArgs(args));
};
} else {
return mergeArgs || readValue || NOOP$1;
}
}
function makeDynamicClosureAction(context, targetRef, actionRef, processArgs, debugKey) {
// We don't allow undefined/null values, so this creates a throw-away action to trigger the assertions
if (false /* DEBUG */) {
makeClosureAction(context, targetRef.value(), actionRef.value(), processArgs, debugKey);
}
return (...args) => {
return makeClosureAction(context, targetRef.value(), actionRef.value(), processArgs, debugKey)(...args);
};
}
function makeClosureAction(context, target, action, processArgs, debugKey) {
let self;
let fn;
false && !(action !== undefined && action !== null) && (0, _debug.assert)(`Action passed is null or undefined in (action) from ${target}.`, action !== undefined && action !== null);
if (typeof action[INVOKE] === 'function') {
self = action;
fn = action[INVOKE];
} else {
let typeofAction = typeof action;
if (typeofAction === 'string') {
self = target;
fn = target.actions && target.actions[action];
false && !fn && (0, _debug.assert)(`An action named '${action}' was not found in ${target}`, fn);
} else if (typeofAction === 'function') {
self = context;
fn = action;
} else {
// eslint:disable-next-line:max-line-length
false && !false && (0, _debug.assert)(`An action could not be made for \`${debugKey || action}\` in ${target}. Please confirm that you are using either a quoted action name (i.e. \`(action '${debugKey || 'myAction'}')\`) or a function available in ${target}.`, false);
}
}
return (...args) => {
let payload = { target: self, args, label: '@glimmer/closure-action' };
return (0, _instrumentation.flaggedInstrument)('interaction.ember-action', payload, () => {
return (0, _runloop.join)(self, fn, ...processArgs(args));
});
};
}
/**
@module ember
*/
/**
Use the `{{array}}` helper to create an array to pass as an option to your
components.
```handlebars
{{my-component people=(array
'Tom Dade'
'Yehuda Katz'
this.myOtherPerson)
}}
```
Would result in an object such as:
```js
['Tom Date', 'Yehuda Katz', this.get('myOtherPerson')]
```
Where the 3rd item in the array is bound to updates of the `myOtherPerson` property.
@method array
@for Ember.Templates.helpers
@param {Array} options
@return {Array} Array
@category array-helper
@since 3.7.0
@public
*/
function array(_vm, args) {
return args.positional.capture();
}
const isEmpty = value => {
return value === null || value === undefined || typeof value.toString !== 'function';
};
const normalizeTextValue = value => {
if (isEmpty(value)) {
return '';
}
return String(value);
};
/**
@module ember
*/
/**
Concatenates the given arguments into a string.
Example:
```handlebars
{{some-component name=(concat firstName " " lastName)}}
{{! would pass name="| `readonly` | `required` | `autofocus` |
| `value` | `placeholder` | `disabled` |
| `size` | `tabindex` | `maxlength` |
| `name` | `min` | `max` |
| `pattern` | `accept` | `autocomplete` |
| `autosave` | `formaction` | `formenctype` |
| `formmethod` | `formnovalidate` | `formtarget` |
| `height` | `inputmode` | `multiple` |
| `step` | `width` | `form` |
| `selectionDirection` | `spellcheck` |
{{mount 'admin' model=userSettings}}
```
Or an inline `hash`, and you can even pass components:
```
Application template!
{{mount 'admin' model=(hash title='Secret Admin' signInButton=(component 'sign-in-button') )}}
{{outlet}}
{{my-footer}}
```
You may also specify a name for the `{{outlet}}`, which is useful when using more than one
`{{outlet}}` in a template:
```handlebars
{{outlet "menu"}}
{{outlet "sidebar"}}
{{outlet "main"}}
```
Your routes can then render into a specific one of these `outlet`s by specifying the `outlet`
attribute in your `renderTemplate` function:
```app/routes/menu.js
import Route from '@ember/routing/route';
export default Route.extend({
renderTemplate() {
this.render({ outlet: 'menu' });
}
});
```
See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
information on how your `route` interacts with the `{{outlet}}` helper.
Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
@method outlet
@param {String} [name]
@for Ember.Templates.helpers
@public
*/
function outletHelper(vm, args) {
let scope = vm.dynamicScope();
let nameRef;
if (args.positional.length === 0) {
nameRef = new _reference.ConstReference('main');
} else {
nameRef = args.positional.at(0);
}
return new OutletComponentReference(new OutletReference(scope.outletState, nameRef));
}
function outletMacro(_name, params, hash, builder) {
let expr = [_wireFormat.Ops.Helper, '-outlet', params || [], hash];
builder.dynamicComponent(expr, null, [], null, false, null, null);
return true;
}
class OutletComponentReference {
constructor(outletRef) {
this.outletRef = outletRef;
this.definition = null;
this.lastState = null;
// The router always dirties the root state.
this.tag = outletRef.tag;
}
value() {
let state = stateFor(this.outletRef);
if (validate(state, this.lastState)) {
return this.definition;
}
this.lastState = state;
let definition = null;
if (state !== null) {
definition = (0, _runtime.curry)(new OutletComponentDefinition(state));
}
return this.definition = definition;
}
get(_key) {
return _runtime.UNDEFINED_REFERENCE;
}
}
function stateFor(ref) {
let outlet = ref.value();
if (outlet === undefined) return null;
let render = outlet.render;
if (render === undefined) return null;
let template = render.template;
if (template === undefined) return null;
return {
ref,
name: render.name,
outlet: render.outlet,
template,
controller: render.controller
};
}
function validate(state, lastState) {
if (state === null) {
return lastState === null;
}
if (lastState === null) {
return false;
}
return state.template === lastState.template && state.controller === lastState.controller;
}
function refineInlineSyntax(name, params, hash, builder) {
false && !!(builder.compiler['resolver']['resolver']['builtInHelpers'][name] && builder.referrer.owner.hasRegistration(`helper:${name}`)) && (0, _debug.assert)(`You attempted to overwrite the built-in helper "${name}" which is not allowed. Please rename the helper.`, !(builder.compiler['resolver']['resolver']['builtInHelpers'][name] && builder.referrer.owner.hasRegistration(`helper:${name}`)));
if (name.indexOf('-') === -1) {
return false;
}
let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);
if (handle !== null) {
builder.component.static(handle, [params === null ? [] : params, hashToArgs(hash), null, null]);
return true;
}
return false;
}
function refineBlockSyntax(name, params, hash, template, inverse, builder) {
if (name.indexOf('-') === -1) {
return false;
}
let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);
if (handle !== null) {
wrapComponentClassAttribute(hash);
builder.component.static(handle, [params, hashToArgs(hash), template, inverse]);
return true;
}
false && !builder.referrer.owner.hasRegistration(`helper:${name}`) && (0, _debug.assert)(`A component or helper named "${name}" could not be found`, builder.referrer.owner.hasRegistration(`helper:${name}`));
false && !!(() => {
const resolver = builder.compiler['resolver']['resolver'];
const { owner, moduleName } = builder.referrer;
if (name === 'component' || resolver['builtInHelpers'][name]) {
return true;
}
let options = { source: `template:${moduleName}` };
return owner.hasRegistration(`helper:${name}`, options) || owner.hasRegistration(`helper:${name}`);
})() && (0, _debug.assert)(`Helpers may not be used in the block form, for example {{#${name}}}{{/${name}}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (${name})}}{{/if}}.`, !(() => {
const resolver = builder.compiler['resolver']['resolver'];const { owner, moduleName } = builder.referrer;if (name === 'component' || resolver['builtInHelpers'][name]) {
return true;
}let options = { source: `template:${moduleName}` };return owner.hasRegistration(`helper:${name}`, options) || owner.hasRegistration(`helper:${name}`);
})());
return false;
}
const experimentalMacros = [];
// This is a private API to allow for experimental macros
// to be created in user space. Registering a macro should
// should be done in an initializer.
function registerMacros(macro) {
experimentalMacros.push(macro);
}
function populateMacros(macros) {
let { inlines, blocks } = macros;
inlines.add('outlet', outletMacro);
inlines.add('mount', mountMacro);
inlines.add('input', inputMacro);
inlines.add('textarea', textAreaMacro);
inlines.addMissing(refineInlineSyntax);
blocks.add('let', blockLetMacro);
blocks.addMissing(refineBlockSyntax);
for (let i = 0; i < experimentalMacros.length; i++) {
let macro = experimentalMacros[i];
macro(blocks, inlines);
}
return { blocks, inlines };
}
function setComponentManager(stringOrFunction, obj) {
let factory;
if (typeof stringOrFunction === 'string') {
factory = function (owner) {
return owner.lookup(`component-manager:${stringOrFunction}`);
};
} else {
factory = stringOrFunction;
}
return setManager(factory, obj);
}
function getComponentManager(obj) {
if (!true /* GLIMMER_CUSTOM_COMPONENT_MANAGER */) {
return;
}
return getManager(obj);
}
function setModifierManager(factory, obj) {
return setManager(factory, obj);
}
function getModifierManager(obj) {
if (!false /* GLIMMER_MODIFIER_MANAGER */) {
return;
}
return getManager(obj);
}
function instrumentationPayload$1(name) {
return { object: `component:${name}` };
}
function makeOptions(moduleName, namespace) {
return {
source: moduleName !== undefined ? `template:${moduleName}` : undefined,
namespace
};
}
const BUILTINS_HELPERS = {
if: inlineIf,
action,
concat: concat$1,
get: get$1,
hash,
array,
log: log$1,
mut,
'query-params': queryParams$1,
readonly,
unbound,
unless: inlineUnless,
'-class': classHelper$1,
'-each-in': eachIn,
'-input-type': inputTypeHelper$1,
'-normalize-class': normalizeClassHelper,
'-html-safe': htmlSafeHelper,
'-get-dynamic-var': _runtime.getDynamicVar,
'-mount': mountHelper,
'-outlet': outletHelper,
'-assert-implicit-component-helper-argument': componentAssertionHelper
};
const BUILTIN_MODIFIERS = {
action: { manager: new ActionModifierManager(), state: null }
};
class RuntimeResolver {
constructor() {
this.handles = [undefined];
this.objToHandle = new WeakMap();
this.builtInHelpers = BUILTINS_HELPERS;
this.builtInModifiers = BUILTIN_MODIFIERS;
// supports directly imported late bound layouts on component.prototype.layout
this.templateCache = new Map();
this.componentDefinitionCache = new Map();
this.customManagerCache = new Map();
this.templateCacheHits = 0;
this.templateCacheMisses = 0;
this.componentDefinitionCount = 0;
this.helperDefinitionCount = 0;
let macros = new _opcodeCompiler.Macros();
populateMacros(macros);
this.compiler = new _opcodeCompiler.LazyCompiler(new CompileTimeLookup(this), this, macros);
}
/*** IRuntimeResolver ***/
/**
* public componentDefHandleCount = 0;
* Called while executing Append Op.PushDynamicComponentManager if string
*/
lookupComponentDefinition(name, meta) {
false && !(name !== 'textarea') && (0, _debug.assert)('You cannot use `textarea` as a component name.', name !== 'textarea');
false && !(name !== 'input') && (0, _debug.assert)('You cannot use `input` as a component name.', name !== 'input');
let handle = this.lookupComponentHandle(name, meta);
if (handle === null) {
false && !false && (0, _debug.assert)(`Could not find component named "${name}" (no component or template with that name was found)`);
return null;
}
return this.resolve(handle);
}
lookupComponentHandle(name, meta) {
let nextHandle = this.handles.length;
let handle = this.handle(this._lookupComponentDefinition(name, meta));
if (nextHandle === handle) {
this.componentDefinitionCount++;
}
return handle;
}
/**
* Called by RuntimeConstants to lookup unresolved handles.
*/
resolve(handle) {
return this.handles[handle];
}
// End IRuntimeResolver
/**
* Called by CompileTimeLookup compiling Unknown or Helper OpCode
*/
lookupHelper(name, meta) {
let nextHandle = this.handles.length;
let helper$$1 = this._lookupHelper(name, meta);
if (helper$$1 !== null) {
let handle = this.handle(helper$$1);
if (nextHandle === handle) {
this.helperDefinitionCount++;
}
return handle;
}
return null;
}
/**
* Called by CompileTimeLookup compiling the
*/
lookupModifier(name, meta) {
return this.handle(this._lookupModifier(name, meta));
}
/**
* Called by CompileTimeLookup to lookup partial
*/
lookupPartial(name, meta) {
let partial = this._lookupPartial(name, meta);
return this.handle(partial);
}
// end CompileTimeLookup
/**
* Creates a template with injections from a directly imported template factory.
* @param templateFactory the directly imported template factory.
* @param owner the owner the template instance would belong to if resolved
*/
createTemplate(factory, owner) {
let cache = this.templateCache.get(owner);
if (cache === undefined) {
cache = new Map();
this.templateCache.set(owner, cache);
}
let template = cache.get(factory);
if (template === undefined) {
const { compiler } = this;
const injections = { compiler };
(0, _owner.setOwner)(injections, owner);
template = factory.create(injections);
cache.set(factory, template);
this.templateCacheMisses++;
} else {
this.templateCacheHits++;
}
return template;
}
// needed for lazy compile time lookup
handle(obj) {
if (obj === undefined || obj === null) {
return null;
}
let handle = this.objToHandle.get(obj);
if (handle === undefined) {
handle = this.handles.push(obj) - 1;
this.objToHandle.set(obj, handle);
}
return handle;
}
_lookupHelper(_name, meta) {
const helper$$1 = this.builtInHelpers[_name];
if (helper$$1 !== undefined) {
return helper$$1;
}
const { owner, moduleName } = meta;
let name = _name;
let namespace = undefined;
if (false /* EMBER_MODULE_UNIFICATION */) {
const parsed = this._parseNameForNamespace(_name);
name = parsed.name;
namespace = parsed.namespace;
}
const options = makeOptions(moduleName, namespace);
const factory = owner.factoryFor(`helper:${name}`, options) || owner.factoryFor(`helper:${name}`);
if (!isHelperFactory(factory)) {
return null;
}
return (vm, args) => {
const helper$$1 = factory.create();
if (isSimpleHelper(helper$$1)) {
return new SimpleHelperReference(helper$$1.compute, args.capture());
}
vm.newDestroyable(helper$$1);
return ClassBasedHelperReference.create(helper$$1, args.capture());
};
}
_lookupPartial(name, meta) {
const template = (0, _views.lookupPartial)(name, meta.owner);
if (template) {
return new _opcodeCompiler.PartialDefinition(name, template);
} else {
throw new Error(`${name} is not a partial`);
}
}
_lookupModifier(name, meta) {
let builtin = this.builtInModifiers[name];
if (false /* GLIMMER_MODIFIER_MANAGER */ && builtin === undefined) {
let { owner } = meta;
let modifier = owner.factoryFor(`modifier:${name}`);
if (modifier !== undefined) {
let managerFactory = getModifierManager(modifier.class);
let manager = managerFactory(owner);
return new CustomModifierDefinition(name, modifier, manager);
}
}
return builtin;
}
_parseNameForNamespace(_name) {
let name = _name;
let namespace = undefined;
let namespaceDelimiterOffset = _name.indexOf('::');
if (namespaceDelimiterOffset !== -1) {
name = _name.slice(namespaceDelimiterOffset + 2);
namespace = _name.slice(0, namespaceDelimiterOffset);
}
return { name, namespace };
}
_lookupComponentDefinition(_name, meta) {
let name = _name;
let namespace = undefined;
if (false /* EMBER_MODULE_UNIFICATION */) {
const parsed = this._parseNameForNamespace(_name);
name = parsed.name;
namespace = parsed.namespace;
}
let { layout, component } = (0, _views.lookupComponent)(meta.owner, name, makeOptions(meta.moduleName, namespace));
let key = component === undefined ? layout : component;
if (key === undefined) {
return null;
}
let cachedComponentDefinition = this.componentDefinitionCache.get(key);
if (cachedComponentDefinition !== undefined) {
return cachedComponentDefinition;
}
let finalizer = (0, _instrumentation._instrumentStart)('render.getComponentDefinition', instrumentationPayload$1, name);
if (layout && !component && _environment2.ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
let definition = new TemplateOnlyComponentDefinition(layout);
finalizer();
this.componentDefinitionCache.set(key, definition);
return definition;
}
if (true /* GLIMMER_CUSTOM_COMPONENT_MANAGER */ && component && component.class) {
let managerFactory = getComponentManager(component.class);
if (managerFactory) {
let delegate = managerFactory(meta.owner);
let definition = new CustomManagerDefinition(name, component, delegate, layout || meta.owner.lookup(_container.privatize`template:components/-default`));
finalizer();
this.componentDefinitionCache.set(key, definition);
return definition;
}
}
let definition = layout || component ? new CurlyComponentDefinition(name, component || meta.owner.factoryFor(_container.privatize`component:-default`), null, layout // TODO fix type
) : null;
finalizer();
this.componentDefinitionCache.set(key, definition);
return definition;
}
_lookupComponentManager(owner, managerId) {
if (this.customManagerCache.has(managerId)) {
return this.customManagerCache.get(managerId);
}
let delegate = owner.lookup(`component-manager:${managerId}`);
this.customManagerCache.set(managerId, delegate);
return delegate;
}
}
// factory for DI
var TemplateCompiler = {
create() {
return new RuntimeResolver().compiler;
}
};
var ComponentTemplate = template({ "id": "chfQcH83", "block": "{\"symbols\":[\"&default\"],\"statements\":[[14,1]],\"hasEval\":false}", "meta": { "moduleName": "packages/@ember/-internals/glimmer/lib/templates/component.hbs" } });
var OutletTemplate = template({ "id": "gK7R0/52", "block": "{\"symbols\":[],\"statements\":[[1,[21,\"outlet\"],false]],\"hasEval\":false}", "meta": { "moduleName": "packages/@ember/-internals/glimmer/lib/templates/outlet.hbs" } });
const TOP_LEVEL_NAME = '-top-level';
const TOP_LEVEL_OUTLET = 'main';
class OutletView {
constructor(_environment, renderer, owner, template) {
this._environment = _environment;
this.renderer = renderer;
this.owner = owner;
this.template = template;
let ref = this.ref = new RootOutletReference({
outlets: { main: undefined },
render: {
owner: owner,
into: undefined,
outlet: TOP_LEVEL_OUTLET,
name: TOP_LEVEL_NAME,
controller: undefined,
template
}
});
this.state = {
ref,
name: TOP_LEVEL_NAME,
outlet: TOP_LEVEL_OUTLET,
template,
controller: undefined
};
}
static extend(injections) {
return class extends OutletView {
static create(options) {
if (options) {
return super.create((0, _polyfills.assign)({}, injections, options));
} else {
return super.create(injections);
}
}
};
}
static reopenClass(injections) {
(0, _polyfills.assign)(this, injections);
}
static create(options) {
let { _environment, renderer, template } = options;
let owner = options[_owner.OWNER];
return new OutletView(_environment, renderer, owner, template);
}
appendTo(selector) {
let target;
if (this._environment.hasDOM) {
target = typeof selector === 'string' ? document.querySelector(selector) : selector;
} else {
target = selector;
}
(0, _runloop.schedule)('render', this.renderer, 'appendOutletView', this, target);
}
rerender() {
/**/
}
setOutletState(state) {
this.ref.update(state);
}
destroy() {
/**/
}
}
function setupApplicationRegistry(registry) {
registry.injection('service:-glimmer-environment', 'appendOperations', 'service:-dom-tree-construction');
registry.injection('renderer', 'env', 'service:-glimmer-environment');
// because we are using injections we can't use instantiate false
// we need to use bind() to copy the function so factory for
// association won't leak
registry.register('service:-dom-builder', {
create({ bootOptions }) {
let { _renderMode } = bootOptions;
switch (_renderMode) {
case 'serialize':
return _node.serializeBuilder.bind(null);
case 'rehydrate':
return _runtime.rehydrationBuilder.bind(null);
default:
return _runtime.clientBuilder.bind(null);
}
}
});
registry.injection('service:-dom-builder', 'bootOptions', '-environment:main');
registry.injection('renderer', 'builder', 'service:-dom-builder');
registry.register(_container.privatize`template:-root`, RootTemplate);
registry.injection('renderer', 'rootTemplate', _container.privatize`template:-root`);
registry.register('renderer:-dom', InteractiveRenderer);
registry.register('renderer:-inert', InertRenderer);
if (_browserEnvironment.hasDOM) {
registry.injection('service:-glimmer-environment', 'updateOperations', 'service:-dom-changes');
}
registry.register('service:-dom-changes', {
create({ document }) {
return new _runtime.DOMChanges(document);
}
});
registry.register('service:-dom-tree-construction', {
create({ document }) {
let Implementation = _browserEnvironment.hasDOM ? _runtime.DOMTreeConstruction : _node.NodeDOMTreeConstruction;
return new Implementation(document);
}
});
}
function setupEngineRegistry(registry) {
registry.register('view:-outlet', OutletView);
registry.register('template:-outlet', OutletTemplate);
registry.injection('view:-outlet', 'template', 'template:-outlet');
registry.injection('service:-dom-changes', 'document', 'service:-document');
registry.injection('service:-dom-tree-construction', 'document', 'service:-document');
registry.register(_container.privatize`template:components/-default`, ComponentTemplate);
registry.register('service:-glimmer-environment', Environment$1);
registry.register(_container.privatize`template-compiler:main`, TemplateCompiler);
registry.injection('template', 'compiler', _container.privatize`template-compiler:main`);
registry.optionsForType('helper', { instantiate: false });
registry.register('helper:loc', loc$1);
registry.register('component:-text-field', TextField);
registry.register('component:-text-area', TextArea);
registry.register('component:-checkbox', Checkbox);
registry.register('component:link-to', LinkComponent);
if (!_environment2.ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
registry.register(_container.privatize`component:-default`, Component);
}
}
/**
[Glimmer](https://github.com/tildeio/glimmer) is a templating engine used by Ember.js that is compatible with a subset of the [Handlebars](http://handlebarsjs.com/) syntax.
### 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:
```app/components/person-profile.js
import Component from '@ember/component';
export default Component.extend({
name: 'Jill'
});
```
```app/templates/components/person-profile.hbs
{{name}}
{{name}}
```
Any time the "name" property on the component changes, the DOM will be
updated.
Properties can be chained as well:
```handlebars
{{aUserModel.name}}
{{listOfUsers.firstObject.name}}
```
### 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"}}
```
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
```
Ember's built-in helpers are described under the [Ember.Templates.helpers](/api/ember/release/classes/Ember.Templates.helpers)
namespace. Documentation on creating custom helpers can be found under
[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 [Component](/api/ember/release/classes/Component).
@module @ember/component
@main @ember/component
@public
*/
exports.RootTemplate = RootTemplate;
exports.template = template;
exports.Checkbox = Checkbox;
exports.TextField = TextField;
exports.TextArea = TextArea;
exports.LinkComponent = LinkComponent;
exports.Component = Component;
exports.ROOT_REF = ROOT_REF;
exports.Helper = Helper;
exports.helper = helper;
exports.Environment = Environment$1;
exports.SafeString = SafeString;
exports.escapeExpression = escapeExpression;
exports.htmlSafe = htmlSafe;
exports.isHTMLSafe = isHTMLSafe;
exports.Renderer = Renderer;
exports.InertRenderer = InertRenderer;
exports.InteractiveRenderer = InteractiveRenderer;
exports._resetRenderers = _resetRenderers;
exports.renderSettled = renderSettled;
exports.getTemplate = getTemplate;
exports.setTemplate = setTemplate;
exports.hasTemplate = hasTemplate;
exports.getTemplates = getTemplates;
exports.setTemplates = setTemplates;
exports.setupEngineRegistry = setupEngineRegistry;
exports.setupApplicationRegistry = setupApplicationRegistry;
exports._registerMacros = registerMacros;
exports._experimentalMacros = experimentalMacros;
exports.AbstractComponentManager = AbstractManager;
exports.UpdatableReference = UpdatableReference;
exports.INVOKE = INVOKE;
exports.iterableFor = iterableFor;
exports.DebugStack = DebugStack$1;
exports.OutletView = OutletView;
exports.capabilities = capabilities;
exports.setComponentManager = setComponentManager;
exports.getComponentManager = getComponentManager;
exports.setModifierManager = setModifierManager;
exports.getModifierManager = getModifierManager;
exports.modifierCapabilties = capabilities$1;
});
enifed('@ember/-internals/meta/index', ['exports', '@ember/-internals/meta/lib/meta'], function (exports, _meta) {
'use strict';
Object.defineProperty(exports, 'counters', {
enumerable: true,
get: function () {
return _meta.counters;
}
});
Object.defineProperty(exports, 'deleteMeta', {
enumerable: true,
get: function () {
return _meta.deleteMeta;
}
});
Object.defineProperty(exports, 'descriptorFor', {
enumerable: true,
get: function () {
return _meta.descriptorFor;
}
});
Object.defineProperty(exports, 'isDescriptor', {
enumerable: true,
get: function () {
return _meta.isDescriptor;
}
});
Object.defineProperty(exports, 'Meta', {
enumerable: true,
get: function () {
return _meta.Meta;
}
});
Object.defineProperty(exports, 'meta', {
enumerable: true,
get: function () {
return _meta.meta;
}
});
Object.defineProperty(exports, 'peekMeta', {
enumerable: true,
get: function () {
return _meta.peekMeta;
}
});
Object.defineProperty(exports, 'setMeta', {
enumerable: true,
get: function () {
return _meta.setMeta;
}
});
Object.defineProperty(exports, 'UNDEFINED', {
enumerable: true,
get: function () {
return _meta.UNDEFINED;
}
});
});
enifed('@ember/-internals/meta/lib/meta', ['exports', '@ember/-internals/utils', '@ember/debug'], function (exports, _utils, _debug) {
'use strict';
exports.counters = exports.meta = exports.Meta = exports.UNDEFINED = undefined;
exports.setMeta = setMeta;
exports.peekMeta = peekMeta;
exports.deleteMeta = deleteMeta;
exports.descriptorFor = descriptorFor;
exports.isDescriptor = isDescriptor;
const objectPrototype = Object.prototype;
let counters;
if (false /* DEBUG */) {
exports.counters = counters = {
peekCalls: 0,
peekPrototypeWalks: 0,
setCalls: 0,
deleteCalls: 0,
metaCalls: 0,
metaInstantiated: 0,
matchingListenersCalls: 0,
addToListenersCalls: 0,
removeFromListenersCalls: 0,
removeAllListenersCalls: 0,
listenersInherited: 0,
listenersFlattened: 0,
parentListenersUsed: 0,
flattenedListenersCalls: 0,
reopensAfterFlatten: 0
};
}
/**
@module ember
*/
const UNDEFINED = exports.UNDEFINED = (0, _utils.symbol)('undefined');
let currentListenerVersion = 1;
class Meta {
constructor(obj) {
this._listenersVersion = 1;
this._inheritedEnd = -1;
this._flattenedVersion = 0;
if (false /* DEBUG */) {
counters.metaInstantiated++;
this._values = undefined;
}
this._parent = undefined;
this._descriptors = undefined;
this._watching = undefined;
this._mixins = undefined;
this._deps = undefined;
this._chainWatchers = undefined;
this._chains = undefined;
this._tag = undefined;
this._tags = undefined;
// initial value for all flags right now is false
// see FLAGS const for detailed list of flags used
this._flags = 0 /* NONE */;
// used only internally
this.source = obj;
this.proto = obj.constructor === undefined ? undefined : obj.constructor.prototype;
this._listeners = undefined;
}
get parent() {
let parent = this._parent;
if (parent === undefined) {
let proto = getPrototypeOf(this.source);
this._parent = parent = proto === null || proto === objectPrototype ? null : meta(proto);
}
return parent;
}
setInitializing() {
this._flags |= 8 /* INITIALIZING */;
}
unsetInitializing() {
this._flags ^= 8 /* INITIALIZING */;
}
isInitializing() {
return this._hasFlag(8 /* INITIALIZING */);
}
isPrototypeMeta(obj) {
return this.proto === this.source && this.source === obj;
}
destroy() {
if (this.isMetaDestroyed()) {
return;
}
this.setMetaDestroyed();
// remove chainWatchers to remove circular references that would prevent GC
let chains = this.readableChains();
if (chains !== undefined) {
chains.destroy();
}
}
isSourceDestroying() {
return this._hasFlag(1 /* SOURCE_DESTROYING */);
}
setSourceDestroying() {
this._flags |= 1 /* SOURCE_DESTROYING */;
}
isSourceDestroyed() {
return this._hasFlag(2 /* SOURCE_DESTROYED */);
}
setSourceDestroyed() {
this._flags |= 2 /* SOURCE_DESTROYED */;
}
isMetaDestroyed() {
return this._hasFlag(4 /* META_DESTROYED */);
}
setMetaDestroyed() {
this._flags |= 4 /* META_DESTROYED */;
}
_hasFlag(flag) {
return (this._flags & flag) === flag;
}
_getOrCreateOwnMap(key) {
return this[key] || (this[key] = Object.create(null));
}
_getOrCreateOwnSet(key) {
return this[key] || (this[key] = new Set());
}
_findInherited1(key) {
let pointer = this;
while (pointer !== null) {
let map = pointer[key];
if (map !== undefined) {
return map;
}
pointer = pointer.parent;
}
}
_findInherited2(key, subkey) {
let pointer = this;
while (pointer !== null) {
let map = pointer[key];
if (map !== undefined) {
let value = map[subkey];
if (value !== undefined) {
return value;
}
}
pointer = pointer.parent;
}
}
_findInherited3(key, subkey, subsubkey) {
let pointer = this;
while (pointer !== null) {
let map = pointer[key];
if (map !== undefined) {
let submap = map[subkey];
if (submap !== undefined) {
let value = submap[subsubkey];
if (value !== undefined) {
return value;
}
}
}
pointer = pointer.parent;
}
}
_hasInInheritedSet(key, value) {
let pointer = this;
while (pointer !== null) {
let set = pointer[key];
if (set !== undefined && set.has(value)) {
return true;
}
pointer = pointer.parent;
}
return false;
}
// Implements a member that provides a lazily created map of maps,
// with inheritance at both levels.
writeDeps(subkey, itemkey, count) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot modify dependent keys for \`${itemkey}\` on \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let outerMap = this._getOrCreateOwnMap('_deps');
let innerMap = outerMap[subkey];
if (innerMap === undefined) {
innerMap = outerMap[subkey] = Object.create(null);
}
innerMap[itemkey] = count;
}
peekDeps(subkey, itemkey) {
let val = this._findInherited3('_deps', subkey, itemkey);
return val === undefined ? 0 : val;
}
hasDeps(subkey) {
let val = this._findInherited2('_deps', subkey);
return val !== undefined;
}
forEachInDeps(subkey, fn) {
let pointer = this;
let seen;
let calls;
while (pointer !== null) {
let map = pointer._deps;
if (map !== undefined) {
let innerMap = map[subkey];
if (innerMap !== undefined) {
for (let innerKey in innerMap) {
seen = seen === undefined ? new Set() : seen;
if (!seen.has(innerKey)) {
seen.add(innerKey);
if (innerMap[innerKey] > 0) {
calls = calls || [];
calls.push(innerKey);
}
}
}
}
}
pointer = pointer.parent;
}
if (calls !== undefined) {
for (let i = 0; i < calls.length; i++) {
fn(calls[i]);
}
}
}
writableTags() {
return this._getOrCreateOwnMap('_tags');
}
readableTags() {
return this._tags;
}
writableTag(create) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot create a new tag for \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let ret = this._tag;
if (ret === undefined) {
ret = this._tag = create(this.source);
}
return ret;
}
readableTag() {
return this._tag;
}
writableChainWatchers(create) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot create a new chain watcher for \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let ret = this._chainWatchers;
if (ret === undefined) {
ret = this._chainWatchers = create(this.source);
}
return ret;
}
readableChainWatchers() {
return this._chainWatchers;
}
writableChains(create) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot create a new chains for \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let { _chains: ret } = this;
if (ret === undefined) {
this._chains = ret = create(this.source);
let { parent } = this;
if (parent !== null) {
let parentChains = parent.writableChains(create);
parentChains.copyTo(ret);
}
}
return ret;
}
readableChains() {
return this._findInherited1('_chains');
}
writeWatching(subkey, value) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot update watchers for \`${subkey}\` on \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let map = this._getOrCreateOwnMap('_watching');
map[subkey] = value;
}
peekWatching(subkey) {
let count = this._findInherited2('_watching', subkey);
return count === undefined ? 0 : count;
}
addMixin(mixin) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot add mixins of \`${(0, _utils.toString)(mixin)}\` on \`${(0, _utils.toString)(this.source)}\` call addMixin after it has been destroyed.` : '', !this.isMetaDestroyed());
let set = this._getOrCreateOwnSet('_mixins');
set.add(mixin);
}
hasMixin(mixin) {
return this._hasInInheritedSet('_mixins', mixin);
}
forEachMixins(fn) {
let pointer = this;
let seen;
while (pointer !== null) {
let set = pointer._mixins;
if (set !== undefined) {
seen = seen === undefined ? new Set() : seen;
// TODO cleanup typing here
set.forEach(mixin => {
if (!seen.has(mixin)) {
seen.add(mixin);
fn(mixin);
}
});
}
pointer = pointer.parent;
}
}
writeDescriptors(subkey, value) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot update descriptors for \`${subkey}\` on \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let map = this._getOrCreateOwnMap('_descriptors');
map[subkey] = value;
}
peekDescriptors(subkey) {
let possibleDesc = this._findInherited2('_descriptors', subkey);
return possibleDesc === UNDEFINED ? undefined : possibleDesc;
}
removeDescriptors(subkey) {
this.writeDescriptors(subkey, UNDEFINED);
}
forEachDescriptors(fn) {
let pointer = this;
let seen;
while (pointer !== null) {
let map = pointer._descriptors;
if (map !== undefined) {
for (let key in map) {
seen = seen === undefined ? new Set() : seen;
if (!seen.has(key)) {
seen.add(key);
let value = map[key];
if (value !== UNDEFINED) {
fn(key, value);
}
}
}
}
pointer = pointer.parent;
}
}
addToListeners(eventName, target, method, once) {
if (false /* DEBUG */) {
counters.addToListenersCalls++;
}
this.pushListener(eventName, target, method, once ? 1 /* ONCE */ : 0 /* ADD */);
}
removeFromListeners(eventName, target, method) {
if (false /* DEBUG */) {
counters.removeFromListenersCalls++;
}
this.pushListener(eventName, target, method, 2 /* REMOVE */);
}
removeAllListeners(event) {
false && !false && (0, _debug.deprecate)('The remove all functionality of removeListener and removeObserver has been deprecated. Remove each listener/observer individually instead.', false, {
id: 'events.remove-all-listeners',
until: '3.9.0',
url: 'https://emberjs.com/deprecations/v3.x#toc_events-remove-all-listeners'
});
if (false /* DEBUG */) {
counters.removeAllListenersCalls++;
}
let listeners = this.writableListeners();
let inheritedEnd = this._inheritedEnd;
// remove all listeners of event name
// adjusting the inheritedEnd if listener is below it
for (let i = listeners.length - 1; i >= 0; i--) {
let listener = listeners[i];
if (listener.event === event) {
listeners.splice(i, 1);
if (i < inheritedEnd) {
inheritedEnd--;
}
}
}
this._inheritedEnd = inheritedEnd;
// we put remove alls at start because rare and easy to check there
listeners.splice(inheritedEnd, 0, {
event,
target: null,
method: null,
kind: 3 /* REMOVE_ALL */
});
}
pushListener(event, target, method, kind) {
let listeners = this.writableListeners();
let i = indexOfListener(listeners, event, target, method);
// remove if found listener was inherited
if (i !== -1 && i < this._inheritedEnd) {
listeners.splice(i, 1);
this._inheritedEnd--;
i = -1;
}
// if not found, push. Note that we must always push if a listener is not
// found, even in the case of a function listener remove, because we may be
// attempting to add or remove listeners _before_ flattening has occured.
if (i === -1) {
false && !!(this.isPrototypeMeta(this.source) && typeof method === 'function') && (0, _debug.deprecate)('Adding function listeners to prototypes has been deprecated. Convert the listener to a string listener, or add it to the instance instead.', !(this.isPrototypeMeta(this.source) && typeof method === 'function'), {
id: 'events.inherited-function-listeners',
until: '3.9.0',
url: 'https://emberjs.com/deprecations/v3.x#toc_events-inherited-function-listeners'
});
false && !!(!this.isPrototypeMeta(this.source) && typeof method === 'function' && kind === 2 /* REMOVE */) && (0, _debug.deprecate)('You attempted to remove a function listener which did not exist on the instance, which means it was an inherited prototype listener, or you attempted to remove it before it was added. Prototype function listeners have been deprecated, and attempting to remove a non-existent function listener this will error in the future.', !(!this.isPrototypeMeta(this.source) && typeof method === 'function' && kind === 2), {
id: 'events.inherited-function-listeners',
until: '3.9.0',
url: 'https://emberjs.com/deprecations/v3.x#toc_events-inherited-function-listeners'
});
listeners.push({
event,
target,
method,
kind
});
} else {
let listener = listeners[i];
// If the listener is our own function listener and we are trying to
// remove it, we want to splice it out entirely so we don't hold onto a
// reference.
if (kind === 2 /* REMOVE */ && listener.kind !== 2 /* REMOVE */ && typeof method === 'function') {
listeners.splice(i, 1);
} else {
// update own listener
listener.kind = kind;
// TODO: Remove this when removing REMOVE_ALL, it won't be necessary
listener.target = target;
listener.method = method;
}
}
}
writableListeners() {
// Check if we need to invalidate and reflatten. We need to do this if we
// have already flattened (flattened version is the current version) and
// we are either writing to a prototype meta OR we have never inherited, and
// may have cached the parent's listeners.
if (this._flattenedVersion === currentListenerVersion && (this.source === this.proto || this._inheritedEnd === -1)) {
if (false /* DEBUG */) {
counters.reopensAfterFlatten++;
}
currentListenerVersion++;
}
// Inherited end has not been set, then we have never created our own
// listeners, but may have cached the parent's
if (this._inheritedEnd === -1) {
this._inheritedEnd = 0;
this._listeners = [];
}
return this._listeners;
}
/**
Flattening is based on a global revision counter. If the revision has
bumped it means that somewhere in a class inheritance chain something has
changed, so we need to reflatten everything. This can only happen if:
1. A meta has been flattened (listener has been called)
2. The meta is a prototype meta with children who have inherited its
listeners
3. A new listener is subsequently added to the meta (e.g. via `.reopen()`)
This is a very rare occurence, so while the counter is global it shouldn't
be updated very often in practice.
*/
flattenedListeners() {
if (false /* DEBUG */) {
counters.flattenedListenersCalls++;
}
if (this._flattenedVersion < currentListenerVersion) {
if (false /* DEBUG */) {
counters.listenersFlattened++;
}
let parent = this.parent;
if (parent !== null) {
// compute
let parentListeners = parent.flattenedListeners();
if (parentListeners !== undefined) {
if (this._listeners === undefined) {
// If this instance doesn't have any of its own listeners (writableListeners
// has never been called) then we don't need to do any flattening, return
// the parent's listeners instead.
if (false /* DEBUG */) {
counters.parentListenersUsed++;
}
this._listeners = parentListeners;
} else {
let listeners = this._listeners;
if (this._inheritedEnd > 0) {
listeners.splice(0, this._inheritedEnd);
this._inheritedEnd = 0;
}
for (let i = 0; i < parentListeners.length; i++) {
let listener = parentListeners[i];
let index = indexOfListener(listeners, listener.event, listener.target, listener.method);
if (index === -1) {
if (false /* DEBUG */) {
counters.listenersInherited++;
}
listeners.unshift(listener);
this._inheritedEnd++;
}
}
}
}
}
this._flattenedVersion = currentListenerVersion;
}
return this._listeners;
}
matchingListeners(eventName) {
let listeners = this.flattenedListeners();
let result;
if (false /* DEBUG */) {
counters.matchingListenersCalls++;
}
if (listeners !== undefined) {
for (let index = 0; index < listeners.length; index++) {
let listener = listeners[index];
// REMOVE and REMOVE_ALL listeners are placeholders that tell us not to
// inherit, so they never match. Only ADD and ONCE can match.
if (listener.event === eventName && (listener.kind === 0 /* ADD */ || listener.kind === 1 /* ONCE */)) {
if (result === undefined) {
// we create this array only after we've found a listener that
// matches to avoid allocations when no matches are found.
result = [];
}
result.push(listener.target, listener.method, listener.kind === 1 /* ONCE */);
}
}
}
return result;
}
}
exports.Meta = Meta;
if (false /* DEBUG */) {
Meta.prototype.writeValues = function (subkey, value) {
false && !!this.isMetaDestroyed() && (0, _debug.assert)(this.isMetaDestroyed() ? `Cannot set the value of \`${subkey}\` on \`${(0, _utils.toString)(this.source)}\` after it has been destroyed.` : '', !this.isMetaDestroyed());
let map = this._getOrCreateOwnMap('_values');
map[subkey] = value;
};
Meta.prototype.peekValues = function (subkey) {
return this._findInherited2('_values', subkey);
};
Meta.prototype.deleteFromValues = function (subkey) {
delete this._getOrCreateOwnMap('_values')[subkey];
};
Meta.prototype.readInheritedValue = function (key, subkey) {
let internalKey = `_${key}`;
let pointer = this;
while (pointer !== null) {
let map = pointer[internalKey];
if (map !== undefined) {
let value = map[subkey];
if (value !== undefined || subkey in map) {
return value;
}
}
pointer = pointer.parent;
}
return UNDEFINED;
};
Meta.prototype.writeValue = function (obj, key, value) {
let descriptor = (0, _utils.lookupDescriptor)(obj, key);
let isMandatorySetter = descriptor !== null && descriptor.set && descriptor.set.isMandatorySetter;
if (isMandatorySetter) {
this.writeValues(key, value);
} else {
obj[key] = value;
}
};
}
const getPrototypeOf = Object.getPrototypeOf;
const metaStore = new WeakMap();
function setMeta(obj, meta) {
false && !(obj !== null) && (0, _debug.assert)('Cannot call `setMeta` on null', obj !== null);
false && !(obj !== undefined) && (0, _debug.assert)('Cannot call `setMeta` on undefined', obj !== undefined);
false && !(typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call \`setMeta\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
if (false /* DEBUG */) {
counters.setCalls++;
}
metaStore.set(obj, meta);
}
function peekMeta(obj) {
false && !(obj !== null) && (0, _debug.assert)('Cannot call `peekMeta` on null', obj !== null);
false && !(obj !== undefined) && (0, _debug.assert)('Cannot call `peekMeta` on undefined', obj !== undefined);
false && !(typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call \`peekMeta\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
if (false /* DEBUG */) {
counters.peekCalls++;
}
let meta = metaStore.get(obj);
if (meta !== undefined) {
return meta;
}
let pointer = getPrototypeOf(obj);
while (pointer !== undefined && pointer !== null) {
if (false /* DEBUG */) {
counters.peekPrototypeWalks++;
}
meta = metaStore.get(pointer);
if (meta !== undefined) {
if (meta.proto !== pointer) {
// The meta was a prototype meta which was not marked as initializing.
// This can happen when a prototype chain was created manually via
// Object.create() and the source object does not have a constructor.
meta.proto = pointer;
}
return meta;
}
pointer = getPrototypeOf(pointer);
}
}
/**
Tears down the meta on an object so that it can be garbage collected.
Multiple calls will have no effect.
@method deleteMeta
@for Ember
@param {Object} obj the object to destroy
@return {void}
@private
*/
function deleteMeta(obj) {
false && !(obj !== null) && (0, _debug.assert)('Cannot call `deleteMeta` on null', obj !== null);
false && !(obj !== undefined) && (0, _debug.assert)('Cannot call `deleteMeta` on undefined', obj !== undefined);
false && !(typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call \`deleteMeta\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
if (false /* DEBUG */) {
counters.deleteCalls++;
}
let meta = peekMeta(obj);
if (meta !== undefined) {
meta.destroy();
}
}
/**
Retrieves the meta hash for an object. If `writable` is true ensures the
hash is writable for this object as well.
The meta object contains information about computed property descriptors as
well as any watched properties and other information. You generally will
not access this information directly but instead work with higher level
methods that manipulate this hash indirectly.
@method meta
@for Ember
@private
@param {Object} obj The object to retrieve meta for
@param {Boolean} [writable=true] Pass `false` if you do not intend to modify
the meta hash, allowing the method to avoid making an unnecessary copy.
@return {Object} the meta hash for an object
*/
const meta = exports.meta = function meta(obj) {
false && !(obj !== null) && (0, _debug.assert)('Cannot call `meta` on null', obj !== null);
false && !(obj !== undefined) && (0, _debug.assert)('Cannot call `meta` on undefined', obj !== undefined);
false && !(typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call \`meta\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
if (false /* DEBUG */) {
counters.metaCalls++;
}
let maybeMeta = peekMeta(obj);
// remove this code, in-favor of explicit parent
if (maybeMeta !== undefined && maybeMeta.source === obj) {
return maybeMeta;
}
let newMeta = new Meta(obj);
setMeta(obj, newMeta);
return newMeta;
};
if (false /* DEBUG */) {
meta._counters = counters;
}
/**
Returns the CP descriptor assocaited with `obj` and `keyName`, if any.
@method descriptorFor
@param {Object} obj the object to check
@param {String} keyName the key to check
@return {Descriptor}
@private
*/
function descriptorFor(obj, keyName, _meta) {
false && !(obj !== null) && (0, _debug.assert)('Cannot call `descriptorFor` on null', obj !== null);
false && !(obj !== undefined) && (0, _debug.assert)('Cannot call `descriptorFor` on undefined', obj !== undefined);
false && !(typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call \`descriptorFor\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
let meta = _meta === undefined ? peekMeta(obj) : _meta;
if (meta !== undefined) {
return meta.peekDescriptors(keyName);
}
}
/**
Check whether a value is a CP descriptor.
@method descriptorFor
@param {any} possibleDesc the value to check
@return {boolean}
@private
*/
function isDescriptor(possibleDesc) {
// TODO make this return `possibleDesc is Descriptor`
return possibleDesc !== undefined && possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor === true;
}
exports.counters = counters;
function indexOfListener(listeners, event, target, method) {
for (let i = listeners.length - 1; i >= 0; i--) {
let listener = listeners[i];
if (listener.event === event && (listener.target === target && listener.method === method || listener.kind === 3 /* REMOVE_ALL */)) {
return i;
}
}
return -1;
}
});
enifed('@ember/-internals/metal', ['exports', '@ember/-internals/utils', '@ember/-internals/meta', '@ember/debug', '@ember/runloop', '@glimmer/reference', '@ember/error', 'ember/version', '@ember/-internals/environment', '@ember/polyfills', '@ember/-internals/owner'], function (exports, _utils, _meta2, _debug, _runloop, _reference, _error, _version, _environment, _polyfills, _owner) {
'use strict';
exports.setNamespaceSearchDisabled = exports.isNamespaceSearchDisabled = exports.removeNamespace = exports.processAllNamespaces = exports.processNamespace = exports.findNamespaces = exports.findNamespace = exports.classToString = exports.addNamespace = exports.NAMESPACES_BY_ID = exports.NAMESPACES = exports.tracked = exports.descriptor = exports.assertNotRendered = exports.didRender = exports.runInTransaction = exports.markObjectAsDirty = exports.tagFor = exports.tagForProperty = exports.setHasViews = exports.InjectedProperty = exports.applyMixin = exports.observer = exports.mixin = exports.aliasMethod = exports.Mixin = exports.removeObserver = exports.addObserver = exports.expandProperties = exports.setProperties = exports.getProperties = exports.Libraries = exports.libraries = exports.watcherCount = exports.watch = exports.unwatch = exports.isWatching = exports.unwatchPath = exports.watchPath = exports.removeChainWatcher = exports.finishChains = exports.ChainNode = exports.unwatchKey = exports.watchKey = exports.Descriptor = exports.defineProperty = exports.PROPERTY_DID_CHANGE = exports.overrideChains = exports.notifyPropertyChange = exports.endPropertyChanges = exports.changeProperties = exports.beginPropertyChanges = exports.isPresent = exports.isBlank = exports.isEmpty = exports.isNone = exports.sendEvent = exports.removeListener = exports.on = exports.hasListeners = exports.addListener = exports.eachProxyArrayDidChange = exports.eachProxyArrayWillChange = exports.eachProxyFor = exports.arrayContentDidChange = exports.arrayContentWillChange = exports.removeArrayObserver = exports.addArrayObserver = exports.replaceInNativeArray = exports.replace = exports.objectAt = exports.trySet = exports.set = exports.getWithDefault = exports.get = exports._getPath = exports.PROXY_CONTENT = exports.deprecateProperty = exports.alias = exports.peekCacheFor = exports.getCachedValueFor = exports.getCacheFor = exports._globalsComputed = exports.ComputedProperty = exports.computed = undefined;
const COMPUTED_PROPERTY_CACHED_VALUES = new WeakMap();
const COMPUTED_PROPERTY_LAST_REVISION = false /* EMBER_METAL_TRACKED_PROPERTIES */ ? new WeakMap() : undefined;
/**
Returns the cached value for a property, if one exists.
This can be useful for peeking at the value of a computed
property that is generated lazily, without accidentally causing
it to be created.
@method cacheFor
@static
@for @ember/object/internals
@param {Object} obj the object whose property you want to check
@param {String} key the name of the property whose cached value you want
to return
@return {Object} the cached value
@public
*/
function getCacheFor(obj) {
let cache = COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
if (cache === undefined) {
cache = new Map();
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
COMPUTED_PROPERTY_LAST_REVISION.set(obj, new Map());
}
COMPUTED_PROPERTY_CACHED_VALUES.set(obj, cache);
}
return cache;
}
function getCachedValueFor(obj, key) {
let cache = COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
if (cache !== undefined) {
return cache.get(key);
}
}
let setLastRevisionFor;
let getLastRevisionFor;
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
setLastRevisionFor = (obj, key, revision) => {
let lastRevision = COMPUTED_PROPERTY_LAST_REVISION.get(obj);
lastRevision.set(key, revision);
};
getLastRevisionFor = (obj, key) => {
let cache = COMPUTED_PROPERTY_LAST_REVISION.get(obj);
if (cache === undefined) {
return 0;
} else {
let revision = cache.get(key);
return revision === undefined ? 0 : revision;
}
};
}
function peekCacheFor(obj) {
return COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
}
const firstDotIndexCache = new _utils.Cache(1000, key => key.indexOf('.'));
function isPath(path) {
return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
}
const AFTER_OBSERVERS = ':change';
function changeEvent(keyName) {
return keyName + AFTER_OBSERVERS;
}
/**
@module @ember/object
*/
/*
The event system uses a series of nested hashes to store listeners on an
object. When a listener is registered, or when an event arrives, these
hashes are consulted to determine which target and action pair to invoke.
The hashes are stored in the object's meta hash, and look like this:
// Object's meta hash
{
listeners: { // variable name: `listenerSet`
"foo:change": [ // variable name: `actions`
target, method, once
]
}
}
*/
/**
Add an event listener
@method addListener
@static
@for @ember/object/events
@param obj
@param {String} eventName
@param {Object|Function} target A target object or a function
@param {Function|String} method A function or the name of a function to be called on `target`
@param {Boolean} once A flag whether a function should only be called once
@public
*/
function addListener(obj, eventName, target, method, once) {
false && !(!!obj && !!eventName) && (0, _debug.assert)('You must pass at least an object and event name to addListener', !!obj && !!eventName);
if (!method && 'function' === typeof target) {
method = target;
target = null;
}
(0, _meta2.meta)(obj).addToListeners(eventName, target, method, once === true);
}
/**
Remove an event listener
Arguments should match those passed to `addListener`.
@method removeListener
@static
@for @ember/object/events
@param obj
@param {String} eventName
@param {Object|Function} target A target object or a function
@param {Function|String} method A function or the name of a function to be called on `target`
@public
*/
function removeListener(obj, eventName, target, method) {
false && !(!!obj && !!eventName) && (0, _debug.assert)('You must pass at least an object and event name to removeListener', !!obj && !!eventName);
if (!method && 'function' === typeof target) {
method = target;
target = null;
}
let m = (0, _meta2.meta)(obj);
if (method === undefined) {
m.removeAllListeners(eventName);
} else {
m.removeFromListeners(eventName, target, method);
}
}
/**
Send an event. The execution of suspended listeners
is skipped, and once listeners are removed. A listener without
a target is executed on the passed object. If an array of actions
is not passed, the actions stored on the passed object are invoked.
@method sendEvent
@static
@for @ember/object/events
@param obj
@param {String} eventName
@param {Array} params Optional parameters for each listener.
@return true
@public
*/
function sendEvent(obj, eventName, params, actions, _meta) {
if (actions === undefined) {
let meta$$1 = _meta === undefined ? (0, _meta2.peekMeta)(obj) : _meta;
actions = typeof meta$$1 === 'object' && meta$$1 !== null && meta$$1.matchingListeners(eventName);
}
if (actions === undefined || actions.length === 0) {
return false;
}
for (let i = actions.length - 3; i >= 0; i -= 3) {
// looping in reverse for once listeners
let target = actions[i];
let method = actions[i + 1];
let once = actions[i + 2];
if (!method) {
continue;
}
if (once) {
removeListener(obj, eventName, target, method);
}
if (!target) {
target = obj;
}
if ('string' === typeof method) {
method = target[method];
}
method.apply(target, params);
}
return true;
}
/**
@private
@method hasListeners
@static
@for @ember/object/events
@param obj
@param {String} eventName
*/
function hasListeners(obj, eventName) {
let meta$$1 = (0, _meta2.peekMeta)(obj);
if (meta$$1 === undefined) {
return false;
}
let matched = meta$$1.matchingListeners(eventName);
return matched !== undefined && matched.length > 0;
}
/**
Define a property as a function that should be executed when
a specified event or events are triggered.
``` javascript
import EmberObject from '@ember/object';
import { on } from '@ember/object/evented';
import { sendEvent } from '@ember/object/events';
let Job = EmberObject.extend({
logCompleted: on('completed', function() {
console.log('Job completed!');
})
});
let job = Job.create();
sendEvent(job, 'completed'); // Logs 'Job completed!'
```
@method on
@static
@for @ember/object/evented
@param {String} eventNames*
@param {Function} func
@return func
@public
*/
function on(...args) {
let func = args.pop();
let events = args;
false && !(typeof func === 'function') && (0, _debug.assert)('on expects function as last argument', typeof func === 'function');
false && !(events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)) && (0, _debug.assert)('on called without valid event names', events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0));
(0, _utils.setListeners)(func, events);
return func;
}
/**
ObserverSet is a data structure used to keep track of observers
that have been deferred.
It ensures that observers are called in the same order that they
were initially triggered.
It also ensures that observers for any object-key pairs are called
only once, even if they were triggered multiple times while
deferred. In this case, the order that the observer is called in
will depend on the first time the observer was triggered.
@private
@class ObserverSet
*/
class ObserverSet {
constructor() {
this.added = new Map();
this.queue = [];
}
add(object, key, event) {
let keys = this.added.get(object);
if (keys === undefined) {
keys = new Set();
this.added.set(object, keys);
}
if (!keys.has(key)) {
this.queue.push(object, key, event);
keys.add(key);
}
}
flush() {
// The queue is saved off to support nested flushes.
let queue = this.queue;
this.added.clear();
this.queue = [];
for (let i = 0; i < queue.length; i += 3) {
let object = queue[i];
let key = queue[i + 1];
let event = queue[i + 2];
if (object.isDestroying || object.isDestroyed) {
continue;
}
sendEvent(object, event, [object, key]);
}
}
}
let hasViews = () => false;
function setHasViews(fn) {
hasViews = fn;
}
function makeTag() {
return _reference.DirtyableTag.create();
}
function tagForProperty(object, propertyKey, _meta) {
if (typeof object !== 'object' || object === null) {
return _reference.CONSTANT_TAG;
}
let meta$$1 = _meta === undefined ? (0, _meta2.meta)(object) : _meta;
if ((0, _utils.isProxy)(object)) {
return tagFor(object, meta$$1);
}
let tags = meta$$1.writableTags();
let tag = tags[propertyKey];
if (tag) {
return tag;
}
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
let pair = (0, _reference.combine)([makeTag(), _reference.UpdatableTag.create(_reference.CONSTANT_TAG)]);
return tags[propertyKey] = pair;
} else {
return tags[propertyKey] = makeTag();
}
}
function tagFor(object, _meta) {
if (typeof object === 'object' && object !== null) {
let meta$$1 = _meta === undefined ? (0, _meta2.meta)(object) : _meta;
return meta$$1.writableTag(makeTag);
} else {
return _reference.CONSTANT_TAG;
}
}
let dirty;
let update;
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
dirty = tag => {
tag.inner.first.inner.dirty();
};
update = (outer, inner) => {
outer.inner.second.inner.update(inner);
};
} else {
dirty = tag => {
tag.inner.dirty();
};
}
function markObjectAsDirty(obj, propertyKey, meta$$1) {
let objectTag = meta$$1.readableTag();
if (objectTag !== undefined) {
if ((0, _utils.isProxy)(obj)) {
objectTag.inner.first.inner.dirty();
} else {
objectTag.inner.dirty();
}
}
let tags = meta$$1.readableTags();
let propertyTag = tags !== undefined ? tags[propertyKey] : undefined;
if (propertyTag !== undefined) {
dirty(propertyTag);
}
if (objectTag !== undefined || propertyTag !== undefined) {
ensureRunloop();
}
}
function ensureRunloop() {
if (hasViews()) {
_runloop.backburner.ensureInstance();
}
}
let runInTransaction;
let didRender;
let assertNotRendered;
// detect-backtracking-rerender by default is debug build only
if (false /* DEBUG */) {
// there are 2 states
// DEBUG
// tracks lastRef and lastRenderedIn per rendered object and key during a transaction
// release everything via normal weakmap semantics by just derefencing the weakmap
// RELEASE
// tracks transactionId per rendered object and key during a transaction
// release everything via normal weakmap semantics by just derefencing the weakmap
class TransactionRunner {
constructor() {
this.transactionId = 0;
this.inTransaction = false;
this.shouldReflush = false;
this.weakMap = new WeakMap();
if (false /* DEBUG */) {
// track templates
this.debugStack = undefined;
}
}
runInTransaction(context$$1, methodName) {
this.before(context$$1);
try {
context$$1[methodName]();
} finally {
this.after();
}
return this.shouldReflush;
}
didRender(object, key, reference) {
if (!this.inTransaction) {
return;
}
if (false /* DEBUG */) {
this.setKey(object, key, {
lastRef: reference,
lastRenderedIn: this.debugStack.peek()
});
} else {
this.setKey(object, key, this.transactionId);
}
}
assertNotRendered(object, key) {
if (!this.inTransaction) {
return;
}
if (this.hasRendered(object, key)) {
if (false /* DEBUG */) {
let { lastRef, lastRenderedIn } = this.getKey(object, key);
let currentlyIn = this.debugStack.peek();
let parts = [];
let label;
if (lastRef !== undefined) {
while (lastRef && lastRef._propertyKey) {
parts.unshift(lastRef._propertyKey);
lastRef = lastRef._parentReference;
}
label = parts.join('.');
} else {
label = 'the same value';
}
false && !false && (0, _debug.assert)(`You modified "${label}" twice on ${object} in a single render. It was rendered in ${lastRenderedIn} and modified in ${currentlyIn}. This was unreliable and slow in Ember 1.x and is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.`, false);
}
this.shouldReflush = true;
}
}
hasRendered(object, key) {
if (!this.inTransaction) {
return false;
}
if (false /* DEBUG */) {
return this.getKey(object, key) !== undefined;
}
return this.getKey(object, key) === this.transactionId;
}
before(context$$1) {
this.inTransaction = true;
this.shouldReflush = false;
if (false /* DEBUG */) {
this.debugStack = context$$1.env.debugStack;
}
}
after() {
this.transactionId++;
this.inTransaction = false;
if (false /* DEBUG */) {
this.debugStack = undefined;
}
this.clearObjectMap();
}
createMap(object) {
let map = Object.create(null);
this.weakMap.set(object, map);
return map;
}
getOrCreateMap(object) {
let map = this.weakMap.get(object);
if (map === undefined) {
map = this.createMap(object);
}
return map;
}
setKey(object, key, value) {
let map = this.getOrCreateMap(object);
map[key] = value;
}
getKey(object, key) {
let map = this.weakMap.get(object);
if (map !== undefined) {
return map[key];
}
}
clearObjectMap() {
this.weakMap = new WeakMap();
}
}
let runner = new TransactionRunner();
exports.runInTransaction = runInTransaction = runner.runInTransaction.bind(runner);
exports.didRender = didRender = runner.didRender.bind(runner);
exports.assertNotRendered = assertNotRendered = runner.assertNotRendered.bind(runner);
} else {
// in production do nothing to detect reflushes
exports.runInTransaction = runInTransaction = (context$$1, methodName) => {
context$$1[methodName]();
return false;
};
}
/**
@module ember
@private
*/
const PROPERTY_DID_CHANGE = (0, _utils.symbol)('PROPERTY_DID_CHANGE');
const observerSet = new ObserverSet();
let deferred = 0;
/**
This function is called just after an object property has changed.
It will notify any observers and clear caches among other things.
Normally you will not need to call this method directly but if for some
reason you can't directly watch a property you can invoke this method
manually.
@method notifyPropertyChange
@for @ember/object
@param {Object} obj The object with the property that will change
@param {String} keyName The property key (or path) that will change.
@param {Meta} meta The objects meta.
@return {void}
@since 3.1.0
@public
*/
function notifyPropertyChange(obj, keyName, _meta) {
let meta$$1 = _meta === undefined ? (0, _meta2.peekMeta)(obj) : _meta;
let hasMeta = meta$$1 !== undefined;
if (hasMeta && (meta$$1.isInitializing() || meta$$1.isPrototypeMeta(obj))) {
return;
}
let possibleDesc = (0, _meta2.descriptorFor)(obj, keyName, meta$$1);
if (possibleDesc !== undefined && typeof possibleDesc.didChange === 'function') {
possibleDesc.didChange(obj, keyName);
}
if (hasMeta && meta$$1.peekWatching(keyName) > 0) {
dependentKeysDidChange(obj, keyName, meta$$1);
chainsDidChange(obj, keyName, meta$$1);
notifyObservers(obj, keyName, meta$$1);
}
if (PROPERTY_DID_CHANGE in obj) {
obj[PROPERTY_DID_CHANGE](keyName);
}
if (hasMeta) {
if (meta$$1.isSourceDestroying()) {
return;
}
markObjectAsDirty(obj, keyName, meta$$1);
}
if (false /* DEBUG */) {
assertNotRendered(obj, keyName);
}
}
const SEEN_MAP = new Map();
let IS_TOP_SEEN_MAP = true;
// called whenever a property has just changed to update dependent keys
function dependentKeysDidChange(obj, depKey, meta$$1) {
if (meta$$1.isSourceDestroying() || !meta$$1.hasDeps(depKey)) {
return;
}
let seen = SEEN_MAP;
let isTop = IS_TOP_SEEN_MAP;
if (isTop) {
IS_TOP_SEEN_MAP = false;
}
iterDeps(notifyPropertyChange, obj, depKey, seen, meta$$1);
if (isTop) {
SEEN_MAP.clear();
IS_TOP_SEEN_MAP = true;
}
}
function iterDeps(method, obj, depKey, seen, meta$$1) {
let current = seen.get(obj);
if (current === undefined) {
current = new Set();
seen.set(obj, current);
}
if (current.has(depKey)) {
return;
}
let possibleDesc;
meta$$1.forEachInDeps(depKey, key => {
possibleDesc = (0, _meta2.descriptorFor)(obj, key, meta$$1);
if (possibleDesc !== undefined && possibleDesc._suspended === obj) {
return;
}
method(obj, key, meta$$1);
});
}
function chainsDidChange(_obj, keyName, meta$$1) {
let chainWatchers = meta$$1.readableChainWatchers();
if (chainWatchers !== undefined) {
chainWatchers.notify(keyName, true, notifyPropertyChange);
}
}
function overrideChains(_obj, keyName, meta$$1) {
let chainWatchers = meta$$1.readableChainWatchers();
if (chainWatchers !== undefined) {
chainWatchers.revalidate(keyName);
}
}
/**
@method beginPropertyChanges
@chainable
@private
*/
function beginPropertyChanges() {
deferred++;
}
/**
@method endPropertyChanges
@private
*/
function endPropertyChanges() {
deferred--;
if (deferred <= 0) {
observerSet.flush();
}
}
/**
Make a series of property changes together in an
exception-safe way.
```javascript
Ember.changeProperties(function() {
obj1.set('foo', mayBlowUpWhenSet);
obj2.set('bar', baz);
});
```
@method changeProperties
@param {Function} callback
@private
*/
function changeProperties(callback) {
beginPropertyChanges();
try {
callback();
} finally {
endPropertyChanges();
}
}
function notifyObservers(obj, keyName, meta$$1) {
if (meta$$1.isSourceDestroying()) {
return;
}
let eventName = changeEvent(keyName);
if (deferred > 0) {
observerSet.add(obj, keyName, eventName);
} else {
sendEvent(obj, eventName, [obj, keyName]);
}
}
/**
@module @ember/object
*/
// ..........................................................
// DESCRIPTOR
//
/**
Objects of this type can implement an interface to respond to requests to
get and set. The default implementation handles simple properties.
@class Descriptor
@private
*/
class Descriptor {
constructor() {
this.isDescriptor = true;
this.enumerable = true;
this.configurable = true;
}
setup(obj, keyName, meta$$1) {
Object.defineProperty(obj, keyName, {
enumerable: this.enumerable,
configurable: this.configurable,
get: DESCRIPTOR_GETTER_FUNCTION(keyName, this)
});
meta$$1.writeDescriptors(keyName, this);
}
teardown(_obj, keyName, meta$$1) {
meta$$1.removeDescriptors(keyName);
}
}
// ..........................................................
// DEFINING PROPERTIES API
//
function MANDATORY_SETTER_FUNCTION(name) {
function SETTER_FUNCTION(value) {
let m = (0, _meta2.peekMeta)(this);
if (m.isInitializing() || m.isPrototypeMeta(this)) {
m.writeValues(name, value);
} else {
false && !false && (0, _debug.assert)(`You must use set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
}
}
return Object.assign(SETTER_FUNCTION, { isMandatorySetter: true });
}
function DEFAULT_GETTER_FUNCTION(name) {
return function GETTER_FUNCTION() {
let meta$$1 = (0, _meta2.peekMeta)(this);
if (meta$$1 !== undefined) {
return meta$$1.peekValues(name);
}
};
}
function INHERITING_GETTER_FUNCTION(name) {
function IGETTER_FUNCTION() {
let meta$$1 = (0, _meta2.peekMeta)(this);
let val;
if (meta$$1 !== undefined) {
val = meta$$1.readInheritedValue('values', name);
}
if (val === _meta2.UNDEFINED) {
let proto = Object.getPrototypeOf(this);
return proto && proto[name];
} else {
return val;
}
}
return Object.assign(IGETTER_FUNCTION, {
isInheritingGetter: true
});
}
function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
return function CPGETTER_FUNCTION() {
return descriptor.get(this, name);
};
}
/**
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
`mixin()` to define new properties.
Defines a property on an object. This method works much like the ES5
`Object.defineProperty()` method except that it can also accept computed
properties and other special descriptors.
Normally this method takes only three parameters. However if you pass an
instance of `Descriptor` as the third param then you can pass an
optional value as the fourth parameter. This is often more efficient than
creating new descriptor hashes for each property.
## Examples
```javascript
import { defineProperty, computed } from '@ember/object';
// ES5 compatible mode
defineProperty(contact, 'firstName', {
writable: true,
configurable: false,
enumerable: true,
value: 'Charles'
});
// define a simple property
defineProperty(contact, 'lastName', undefined, 'Jolley');
// define a computed property
defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
return this.firstName+' '+this.lastName;
}));
```
@public
@method defineProperty
@static
@for @ember/object
@param {Object} obj the object to define this property on. This may be a prototype.
@param {String} keyName the name of the property
@param {Descriptor} [desc] an instance of `Descriptor` (typically a
computed property) or an ES5 descriptor.
You must provide this or `data` but not both.
@param {*} [data] something other than a descriptor, that will
become the explicit value of this property.
*/
function defineProperty(obj, keyName, desc, data, meta$$1) {
if (meta$$1 === undefined) {
meta$$1 = (0, _meta2.meta)(obj);
}
let watching = meta$$1.peekWatching(keyName) > 0;
let previousDesc = (0, _meta2.descriptorFor)(obj, keyName, meta$$1);
let wasDescriptor = previousDesc !== undefined;
if (wasDescriptor) {
previousDesc.teardown(obj, keyName, meta$$1);
}
// used to track if the the property being defined be enumerable
let enumerable = true;
// Ember.NativeArray is a normal Ember.Mixin that we mix into `Array.prototype` when prototype extensions are enabled
// mutating a native object prototype like this should _not_ result in enumerable properties being added (or we have significant
// issues with things like deep equality checks from test frameworks, or things like jQuery.extend(true, [], [])).
//
// this is a hack, and we should stop mutating the array prototype by default 😫
if (obj === Array.prototype) {
enumerable = false;
}
let value;
if (desc instanceof Descriptor) {
value = desc;
desc.setup(obj, keyName, meta$$1);
} else if (desc === undefined || desc === null) {
value = data;
if (false /* DEBUG */ && watching) {
meta$$1.writeValues(keyName, data);
let defaultDescriptor = {
configurable: true,
enumerable,
set: MANDATORY_SETTER_FUNCTION(keyName),
get: DEFAULT_GETTER_FUNCTION(keyName)
};
Object.defineProperty(obj, keyName, defaultDescriptor);
} else if (wasDescriptor || enumerable === false) {
Object.defineProperty(obj, keyName, {
configurable: true,
enumerable,
writable: true,
value
});
} else {
obj[keyName] = data;
}
} else {
value = desc;
// fallback to ES5
Object.defineProperty(obj, keyName, desc);
}
// if key is being watched, override chains that
// were initialized with the prototype
if (watching) {
overrideChains(obj, keyName, meta$$1);
}
// The `value` passed to the `didDefineProperty` hook is
// either the descriptor or data, whichever was passed.
if (typeof obj.didDefineProperty === 'function') {
obj.didDefineProperty(obj, keyName, value);
}
}
let handleMandatorySetter;
function watchKey(obj, keyName, _meta) {
let meta$$1 = _meta === undefined ? (0, _meta2.meta)(obj) : _meta;
let count = meta$$1.peekWatching(keyName);
meta$$1.writeWatching(keyName, count + 1);
if (count === 0) {
// activate watching first time
let possibleDesc = (0, _meta2.descriptorFor)(obj, keyName, meta$$1);
if (possibleDesc !== undefined && possibleDesc.willWatch !== undefined) {
possibleDesc.willWatch(obj, keyName, meta$$1);
}
if (typeof obj.willWatchProperty === 'function') {
obj.willWatchProperty(keyName);
}
if (false /* DEBUG */) {
// NOTE: this is dropped for prod + minified builds
handleMandatorySetter(meta$$1, obj, keyName);
}
}
}
if (false /* DEBUG */) {
let hasOwnProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
let propertyIsEnumerable = (obj, key) => Object.prototype.propertyIsEnumerable.call(obj, key);
// 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) {
let descriptor = (0, _utils.lookupDescriptor)(obj, keyName);
let hasDescriptor = descriptor !== null;
let possibleDesc = hasDescriptor && descriptor.value;
if ((0, _meta2.isDescriptor)(possibleDesc)) {
return;
}
let configurable = hasDescriptor ? descriptor.configurable : true;
let isWritable = hasDescriptor ? descriptor.writable : true;
let hasValue = hasDescriptor ? 'value' in descriptor : true;
// this x in Y deopts, so keeping it in this function is better;
if (configurable && isWritable && hasValue && keyName in obj) {
let desc = {
configurable: true,
set: MANDATORY_SETTER_FUNCTION(keyName),
enumerable: propertyIsEnumerable(obj, keyName),
get: undefined
};
if (hasOwnProperty(obj, keyName)) {
m.writeValues(keyName, obj[keyName]);
desc.get = DEFAULT_GETTER_FUNCTION(keyName);
} else {
desc.get = INHERITING_GETTER_FUNCTION(keyName);
}
Object.defineProperty(obj, keyName, desc);
}
};
}
function unwatchKey(obj, keyName, _meta) {
let meta$$1 = _meta === undefined ? (0, _meta2.peekMeta)(obj) : _meta;
// do nothing of this object has already been destroyed
if (meta$$1 === undefined || meta$$1.isSourceDestroyed()) {
return;
}
let count = meta$$1.peekWatching(keyName);
if (count === 1) {
meta$$1.writeWatching(keyName, 0);
let possibleDesc = (0, _meta2.descriptorFor)(obj, keyName, meta$$1);
let isDescriptor$$1 = possibleDesc !== undefined;
if (isDescriptor$$1 && possibleDesc.didUnwatch !== undefined) {
possibleDesc.didUnwatch(obj, keyName, meta$$1);
}
if (typeof obj.didUnwatchProperty === 'function') {
obj.didUnwatchProperty(keyName);
}
if (false /* DEBUG */) {
// 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 (!isDescriptor$$1 && keyName in obj) {
let maybeMandatoryDescriptor = (0, _utils.lookupDescriptor)(obj, keyName);
if (maybeMandatoryDescriptor && maybeMandatoryDescriptor.set && maybeMandatoryDescriptor.set.isMandatorySetter) {
if (maybeMandatoryDescriptor.get && maybeMandatoryDescriptor.get.isInheritingGetter) {
let possibleValue = meta$$1.readInheritedValue('values', keyName);
if (possibleValue === _meta2.UNDEFINED) {
delete obj[keyName];
return;
}
}
Object.defineProperty(obj, keyName, {
configurable: true,
enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
writable: true,
value: meta$$1.peekValues(keyName)
});
meta$$1.deleteFromValues(keyName);
}
}
}
} else if (count > 1) {
meta$$1.writeWatching(keyName, count - 1);
}
}
const EACH_PROXIES = new WeakMap();
function eachProxyArrayWillChange(array, idx, removedCnt, addedCnt) {
let eachProxy = EACH_PROXIES.get(array);
if (eachProxy !== undefined) {
eachProxy.arrayWillChange(array, idx, removedCnt, addedCnt);
}
}
function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
let eachProxy = EACH_PROXIES.get(array);
if (eachProxy !== undefined) {
eachProxy.arrayDidChange(array, idx, removedCnt, addedCnt);
}
}
function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
// if no args are passed assume everything changes
if (startIdx === undefined) {
startIdx = 0;
removeAmt = addAmt = -1;
} else {
if (removeAmt === undefined) {
removeAmt = -1;
}
if (addAmt === undefined) {
addAmt = -1;
}
}
eachProxyArrayWillChange(array, startIdx, removeAmt, addAmt);
sendEvent(array, '@array:before', [array, startIdx, removeAmt, addAmt]);
return array;
}
function arrayContentDidChange(array, startIdx, removeAmt, addAmt) {
// if no args are passed assume everything changes
if (startIdx === undefined) {
startIdx = 0;
removeAmt = addAmt = -1;
} else {
if (removeAmt === undefined) {
removeAmt = -1;
}
if (addAmt === undefined) {
addAmt = -1;
}
}
let meta$$1 = (0, _meta2.peekMeta)(array);
if (addAmt < 0 || removeAmt < 0 || addAmt - removeAmt !== 0) {
notifyPropertyChange(array, 'length', meta$$1);
}
notifyPropertyChange(array, '[]', meta$$1);
eachProxyArrayDidChange(array, startIdx, removeAmt, addAmt);
sendEvent(array, '@array:change', [array, startIdx, removeAmt, addAmt]);
let cache = peekCacheFor(array);
if (cache !== undefined) {
let length = array.length;
let addedAmount = addAmt === -1 ? 0 : addAmt;
let removedAmount = removeAmt === -1 ? 0 : removeAmt;
let delta = addedAmount - removedAmount;
let previousLength = length - delta;
let normalStartIdx = startIdx < 0 ? previousLength + startIdx : startIdx;
if (cache.has('firstObject') && normalStartIdx === 0) {
notifyPropertyChange(array, 'firstObject', meta$$1);
}
if (cache.has('lastObject')) {
let previousLastIndex = previousLength - 1;
let lastAffectedIndex = normalStartIdx + removedAmount;
if (previousLastIndex < lastAffectedIndex) {
notifyPropertyChange(array, 'lastObject', meta$$1);
}
}
}
return array;
}
/**
An object that that tracks @tracked properties that were consumed.
@private
*/
class Tracker {
constructor() {
this.tags = new Set();
this.last = null;
}
add(tag) {
this.tags.add(tag);
this.last = tag;
}
get size() {
return this.tags.size;
}
combine() {
if (this.tags.size === 0) {
return _reference.CONSTANT_TAG;
} else if (this.tags.size === 1) {
return this.last;
} else {
let tags = [];
this.tags.forEach(tag => tags.push(tag));
return (0, _reference.combine)(tags);
}
}
}
function tracked(...dependencies) {
let [, key, descriptor] = dependencies;
if (descriptor === undefined || 'initializer' in descriptor) {
return descriptorForDataProperty(key, descriptor);
} else {
return descriptorForAccessor(key, descriptor);
}
}
/**
@private
Whenever a tracked computed property is entered, the current tracker is
saved off and a new tracker is replaced.
Any tracked properties consumed are added to the current tracker.
When a tracked computed property is exited, the tracker's tags are
combined and added to the parent tracker.
The consequence is that each tracked computed property has a tag
that corresponds to the tracked properties consumed inside of
itself, including child tracked computed properties.
*/
let CURRENT_TRACKER = null;
function getCurrentTracker() {
return CURRENT_TRACKER;
}
function setCurrentTracker(tracker = new Tracker()) {
return CURRENT_TRACKER = tracker;
}
function descriptorForAccessor(key, descriptor) {
let get = descriptor.get;
let set = descriptor.set;
function getter() {
// Swap the parent tracker for a new tracker
let old = CURRENT_TRACKER;
let tracker = CURRENT_TRACKER = new Tracker();
// Call the getter
let ret = get.call(this);
// Swap back the parent tracker
CURRENT_TRACKER = old;
// Combine the tags in the new tracker and add them to the parent tracker
let tag = tracker.combine();
if (CURRENT_TRACKER) CURRENT_TRACKER.add(tag);
// Update the UpdatableTag for this property with the tag for all of the
// consumed dependencies.
update(tagForProperty(this, key), tag);
return ret;
}
function setter() {
dirty(tagForProperty(this, key));
set.apply(this, arguments);
}
return {
enumerable: true,
configurable: false,
get: get && getter,
set: set && setter
};
}
/**
@private
A getter/setter for change tracking for a particular key. The accessor
acts just like a normal property, but it triggers the `propertyDidChange`
hook when written to.
Values are saved on the object using a "shadow key," or a symbol based on the
tracked property name. Sets write the value to the shadow key, and gets read
from it.
*/
function descriptorForDataProperty(key, descriptor) {
let shadowKey = Symbol(key);
return {
enumerable: true,
configurable: true,
get() {
if (CURRENT_TRACKER) CURRENT_TRACKER.add(tagForProperty(this, key));
if (!(shadowKey in this)) {
this[shadowKey] = descriptor.value;
}
return this[shadowKey];
},
set(newValue) {
tagFor(this).inner['dirty']();
dirty(tagForProperty(this, key));
this[shadowKey] = newValue;
propertyDidChange();
}
};
}
let propertyDidChange = function () {};
/**
@module @ember/object
*/
const PROXY_CONTENT = (0, _utils.symbol)('PROXY_CONTENT');
let getPossibleMandatoryProxyValue;
if (false /* DEBUG */ && _utils.HAS_NATIVE_PROXY) {
getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
let content = obj[PROXY_CONTENT];
if (content === undefined) {
return obj[keyName];
} else {
/* global Reflect */
return Reflect.get(content, keyName, obj);
}
};
}
// ..........................................................
// GET AND SET
//
// If we are on a platform that supports accessors we can use those.
// Otherwise simulate accessors by looking up the property directly on the
// object.
/**
Gets the value of a property on an object. If the property is computed,
the function will be invoked. If the property is not defined but the
object implements the `unknownProperty` method then that will be invoked.
```javascript
import { get } from '@ember/object';
get(obj, "name");
```
If you plan to run on IE8 and older browsers then you should use this
method anytime you want to retrieve a property on an object that you don't
know for sure is private. (Properties beginning with an underscore '_'
are considered private.)
On all newer browsers, you only need to use this method to retrieve
properties if the property might not be defined on the object and you want
to respect the `unknownProperty` handler. Otherwise you can ignore this
method.
Note that if the object itself is `undefined`, this method will throw
an error.
@method get
@for @ember/object
@static
@param {Object} obj The object to retrieve from.
@param {String} keyName The property key to retrieve
@return {Object} the property value or `null`.
@public
*/
function get(obj, keyName) {
false && !(arguments.length === 2) && (0, _debug.assert)(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
false && !(obj !== undefined && obj !== null) && (0, _debug.assert)(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
false && !(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && (0, _debug.assert)(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
false && !(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && (0, _debug.assert)(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
let type = typeof obj;
let isObject = type === 'object';
let isFunction = type === 'function';
let isObjectLike = isObject || isFunction;
let descriptor;
let value;
if (isObjectLike) {
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
let tracker = getCurrentTracker();
if (tracker) tracker.add(tagForProperty(obj, keyName));
}
descriptor = (0, _meta2.descriptorFor)(obj, keyName);
if (descriptor !== undefined) {
return descriptor.get(obj, keyName);
}
if (false /* DEBUG */ && _utils.HAS_NATIVE_PROXY) {
value = getPossibleMandatoryProxyValue(obj, keyName);
} else {
value = obj[keyName];
}
} else {
value = obj[keyName];
}
if (value === undefined) {
if (isPath(keyName)) {
return _getPath(obj, keyName);
}
if (isObject && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
return obj.unknownProperty(keyName);
}
}
return value;
}
function _getPath(root, path) {
let obj = root;
let parts = path.split('.');
for (let i = 0; i < parts.length; i++) {
if (obj === undefined || obj === null || obj.isDestroyed) {
return undefined;
}
obj = get(obj, parts[i]);
}
return obj;
}
/**
Retrieves the value of a property from an Object, or a default value in the
case that the property returns `undefined`.
```javascript
import { getWithDefault } from '@ember/object';
getWithDefault(person, 'lastName', 'Doe');
```
@method getWithDefault
@for @ember/object
@static
@param {Object} obj The object to retrieve from.
@param {String} keyName The name of the property to retrieve
@param {Object} defaultValue The value to return if the property value is undefined
@return {Object} The property value or the defaultValue.
@public
*/
function getWithDefault(root, key, defaultValue) {
let value = get(root, key);
if (value === undefined) {
return defaultValue;
}
return value;
}
const EMPTY_ARRAY = Object.freeze([]);
function objectAt(array, index) {
if (Array.isArray(array)) {
return array[index];
} else {
return array.objectAt(index);
}
}
function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
if (Array.isArray(array)) {
replaceInNativeArray(array, start, deleteCount, items);
} else {
array.replace(start, deleteCount, items);
}
}
const CHUNK_SIZE = 60000;
// To avoid overflowing the stack, we splice up to CHUNK_SIZE items at a time.
// See https://code.google.com/p/chromium/issues/detail?id=56588 for more details.
function replaceInNativeArray(array, start, deleteCount, items) {
arrayContentWillChange(array, start, deleteCount, items.length);
if (items.length <= CHUNK_SIZE) {
array.splice(start, deleteCount, ...items);
} else {
array.splice(start, deleteCount);
for (let i = 0; i < items.length; i += CHUNK_SIZE) {
let chunk = items.slice(i, i + CHUNK_SIZE);
array.splice(start + i, 0, ...chunk);
}
}
arrayContentDidChange(array, start, deleteCount, items.length);
}
function arrayObserversHelper(obj, target, opts, operation, notify) {
let willChange = opts && opts.willChange || 'arrayWillChange';
let didChange = opts && opts.didChange || 'arrayDidChange';
let hasObservers = get(obj, 'hasArrayObservers');
operation(obj, '@array:before', target, willChange);
operation(obj, '@array:change', target, didChange);
if (hasObservers === notify) {
notifyPropertyChange(obj, 'hasArrayObservers');
}
return obj;
}
function addArrayObserver(array, target, opts) {
return arrayObserversHelper(array, target, opts, addListener, false);
}
function removeArrayObserver(array, target, opts) {
return arrayObserversHelper(array, target, opts, removeListener, true);
}
/**
@module @ember/object
*/
/**
@method addObserver
@static
@for @ember/object/observers
@param obj
@param {String} path
@param {Object|Function} target
@param {Function|String} [method]
@public
*/
function addObserver(obj, path, target, method) {
addListener(obj, changeEvent(path), target, method);
watch(obj, path);
}
/**
@method removeObserver
@static
@for @ember/object/observers
@param obj
@param {String} path
@param {Object|Function} target
@param {Function|String} [method]
@public
*/
function removeObserver(obj, path, target, method) {
unwatch(obj, path);
removeListener(obj, changeEvent(path), target, method);
}
function eachProxyFor(array) {
let eachProxy = EACH_PROXIES.get(array);
if (eachProxy === undefined) {
eachProxy = new EachProxy(array);
EACH_PROXIES.set(array, eachProxy);
}
return eachProxy;
}
class EachProxy {
constructor(content) {
this._content = content;
this._keys = undefined;
(0, _meta2.meta)(this);
}
// ..........................................................
// ARRAY CHANGES
// Invokes whenever the content array itself changes.
arrayWillChange(content, idx, removedCnt /*, addedCnt */) {
// eslint-disable-line no-unused-vars
let keys = this._keys;
if (!keys) {
return;
}
let lim = removedCnt > 0 ? idx + removedCnt : -1;
if (lim > 0) {
for (let key in keys) {
removeObserverForContentKey(content, key, this, idx, lim);
}
}
}
arrayDidChange(content, idx, _removedCnt, addedCnt) {
let keys = this._keys;
if (!keys) {
return;
}
let lim = addedCnt > 0 ? idx + addedCnt : -1;
let meta$$1 = (0, _meta2.peekMeta)(this);
for (let key in keys) {
if (lim > 0) {
addObserverForContentKey(content, key, this, idx, lim);
}
notifyPropertyChange(this, key, meta$$1);
}
}
// ..........................................................
// LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
// Start monitoring keys based on who is listening...
willWatchProperty(property) {
this.beginObservingContentKey(property);
}
didUnwatchProperty(property) {
this.stopObservingContentKey(property);
}
// ..........................................................
// CONTENT KEY OBSERVING
// Actual watch keys on the source content.
beginObservingContentKey(keyName) {
let keys = this._keys;
if (keys === undefined) {
keys = this._keys = Object.create(null);
}
if (!keys[keyName]) {
keys[keyName] = 1;
let content = this._content;
let len = content.length;
addObserverForContentKey(content, keyName, this, 0, len);
} else {
keys[keyName]++;
}
}
stopObservingContentKey(keyName) {
let keys = this._keys;
if (keys !== undefined && keys[keyName] > 0 && --keys[keyName] <= 0) {
let content = this._content;
let len = content.length;
removeObserverForContentKey(content, keyName, this, 0, len);
}
}
contentKeyDidChange(_obj, keyName) {
notifyPropertyChange(this, keyName);
}
}
function addObserverForContentKey(content, keyName, proxy, idx, loc) {
while (--loc >= idx) {
let item = objectAt(content, loc);
if (item) {
false && !(typeof item === 'object') && (0, _debug.assert)(`When using @each to observe the array \`${content.toString()}\`, the array must return an object`, typeof item === 'object');
addObserver(item, keyName, proxy, 'contentKeyDidChange');
}
}
}
function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
while (--loc >= idx) {
let item = objectAt(content, loc);
if (item) {
removeObserver(item, keyName, proxy, 'contentKeyDidChange');
}
}
}
function isObject(obj) {
return typeof obj === 'object' && obj !== null;
}
function isVolatile(obj, keyName, meta$$1) {
let desc = (0, _meta2.descriptorFor)(obj, keyName, meta$$1);
return !(desc !== undefined && desc._volatile === false);
}
class ChainWatchers {
constructor() {
// chain nodes that reference a key in this obj by key
// we only create ChainWatchers when we are going to add them
// so create this upfront
this.chains = Object.create(null);
}
add(key, node) {
let nodes = this.chains[key];
if (nodes === undefined) {
this.chains[key] = [node];
} else {
nodes.push(node);
}
}
remove(key, node) {
let nodes = this.chains[key];
if (nodes !== undefined) {
for (let i = 0; i < nodes.length; i++) {
if (nodes[i] === node) {
nodes.splice(i, 1);
break;
}
}
}
}
has(key, node) {
let nodes = this.chains[key];
if (nodes !== undefined) {
for (let i = 0; i < nodes.length; i++) {
if (nodes[i] === node) {
return true;
}
}
}
return false;
}
revalidateAll() {
for (let key in this.chains) {
this.notify(key, true, undefined);
}
}
revalidate(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 object and path that
// will be/are invalidated by this key change, depending on
// whether the revalidate flag is passed
notify(key, revalidate, callback) {
let nodes = this.chains[key];
if (nodes === undefined || nodes.length === 0) {
return;
}
let affected = undefined;
if (callback !== undefined) {
affected = [];
}
for (let i = 0; i < nodes.length; i++) {
nodes[i].notify(revalidate, affected);
}
if (callback === undefined) {
return;
}
// we gather callbacks so we don't notify them during revalidation
for (let i = 0; i < affected.length; i += 2) {
let obj = affected[i];
let path = affected[i + 1];
callback(obj, path);
}
}
}
function makeChainWatcher() {
return new ChainWatchers();
}
function makeChainNode(obj) {
return new ChainNode(null, null, obj);
}
function addChainWatcher(obj, keyName, node) {
let m = (0, _meta2.meta)(obj);
m.writableChainWatchers(makeChainWatcher).add(keyName, node);
watchKey(obj, keyName, m);
}
function removeChainWatcher(obj, keyName, node, _meta) {
if (!isObject(obj)) {
return;
}
let meta$$1 = _meta === undefined ? (0, _meta2.peekMeta)(obj) : _meta;
if (meta$$1 === undefined || meta$$1.isSourceDestroying() || meta$$1.isMetaDestroyed() || meta$$1.readableChainWatchers() === undefined) {
return;
}
// make meta writable
meta$$1 = (0, _meta2.meta)(obj);
meta$$1.readableChainWatchers().remove(keyName, node);
unwatchKey(obj, keyName, meta$$1);
}
const NODE_STACK = [];
function destroyRoot(root) {
pushChildren(root);
while (NODE_STACK.length > 0) {
let node = NODE_STACK.pop();
pushChildren(node);
destroyOne(node);
}
}
function destroyOne(node) {
if (node.isWatching) {
removeChainWatcher(node.object, node.key, node);
node.isWatching = false;
}
}
function pushChildren(node) {
let nodes = node.chains;
if (nodes !== undefined) {
for (let key in nodes) {
if (nodes[key] !== undefined) {
NODE_STACK.push(nodes[key]);
}
}
}
}
// A ChainNode watches a single key on an object. If you provide a starting
// value for the key then the node won't actually watch it. For a root node
// pass null for parent and key and object for value.
class ChainNode {
constructor(parent, key, value) {
this.paths = undefined;
this.isWatching = false;
this.chains = undefined;
this.object = undefined;
this.count = 0;
this.parent = parent;
this.key = key;
this.content = value;
// It is false for the root of a chain (because we have no parent)
let isWatching = this.isWatching = parent !== null;
if (isWatching) {
let parentValue = parent.value();
if (isObject(parentValue)) {
this.object = parentValue;
addChainWatcher(parentValue, key, this);
}
}
}
value() {
if (this.content === undefined && this.isWatching) {
let obj = this.parent.value();
this.content = lazyGet(obj, this.key);
}
return this.content;
}
destroy() {
// check if root
if (this.parent === null) {
destroyRoot(this);
} else {
destroyOne(this);
}
}
// copies a top level object only
copyTo(target) {
let paths = this.paths;
if (paths !== undefined) {
let path;
for (path in paths) {
if (paths[path] > 0) {
target.add(path);
}
}
}
}
// called on the root node of a chain to setup watchers on the specified
// path.
add(path) {
let paths = this.paths || (this.paths = {});
paths[path] = (paths[path] || 0) + 1;
let tails = path.split('.');
this.chain(tails.shift(), tails);
}
// called on the root node of a chain to teardown watcher on the specified
// path
remove(path) {
let paths = this.paths;
if (paths === undefined) {
return;
}
if (paths[path] > 0) {
paths[path]--;
}
let tails = path.split('.');
this.unchain(tails.shift(), tails);
}
chain(key, tails) {
let chains = this.chains;
if (chains === undefined) {
chains = this.chains = Object.create(null);
}
let node = chains[key];
if (node === undefined) {
node = chains[key] = new ChainNode(this, key, undefined);
}
node.count++; // count chains...
// chain rest of path if there is one
if (tails.length > 0) {
node.chain(tails.shift(), tails);
}
}
unchain(key, tails) {
let chains = this.chains;
let node = chains[key];
// unchain rest of path first...
if (tails.length > 0) {
node.unchain(tails.shift(), tails);
}
// delete node if needed.
node.count--;
if (node.count <= 0) {
chains[node.key] = undefined;
node.destroy();
}
}
notify(revalidate, affected) {
if (revalidate && this.isWatching) {
let parentValue = this.parent.value();
if (parentValue !== this.object) {
removeChainWatcher(this.object, this.key, this);
if (isObject(parentValue)) {
this.object = parentValue;
addChainWatcher(parentValue, this.key, this);
} else {
this.object = undefined;
}
}
this.content = undefined;
}
// then notify chains...
let chains = this.chains;
if (chains !== undefined) {
let node;
for (let key in chains) {
node = chains[key];
if (node !== undefined) {
node.notify(revalidate, affected);
}
}
}
if (affected !== undefined && this.parent !== null) {
this.parent.populateAffected(this.key, 1, affected);
}
}
populateAffected(path, depth, affected) {
if (this.key) {
path = `${this.key}.${path}`;
}
if (this.parent !== null) {
this.parent.populateAffected(path, depth + 1, affected);
} else if (depth > 1) {
affected.push(this.value(), path);
}
}
}
function lazyGet(obj, key) {
if (!isObject(obj)) {
return;
}
let meta$$1 = (0, _meta2.peekMeta)(obj);
// check if object meant only to be a prototype
if (meta$$1 !== undefined && meta$$1.proto === obj) {
return;
}
// Use `get` if the return value is an EachProxy or an uncacheable value.
if (key === '@each') {
return eachProxyFor(obj);
} else if (isVolatile(obj, key, meta$$1)) {
return get(obj, key);
// Otherwise attempt to get the cached value of the computed property
} else {
return getCachedValueFor(obj, key);
}
}
function finishChains(meta$$1) {
// finish any current chains node watchers that reference obj
let chainWatchers = meta$$1.readableChainWatchers();
if (chainWatchers !== undefined) {
chainWatchers.revalidateAll();
}
// ensure that if we have inherited any chains they have been
// copied onto our own meta.
if (meta$$1.readableChains() !== undefined) {
meta$$1.writableChains(makeChainNode);
}
}
function watchPath(obj, keyPath, meta$$1) {
let m = meta$$1 === undefined ? (0, _meta2.meta)(obj) : meta$$1;
let counter = m.peekWatching(keyPath);
m.writeWatching(keyPath, counter + 1);
if (counter === 0) {
// activate watching first time
m.writableChains(makeChainNode).add(keyPath);
}
}
function unwatchPath(obj, keyPath, meta$$1) {
let m = meta$$1 === undefined ? (0, _meta2.peekMeta)(obj) : meta$$1;
if (m === undefined) {
return;
}
let counter = m.peekWatching(keyPath);
if (counter > 0) {
m.writeWatching(keyPath, counter - 1);
if (counter === 1) {
m.writableChains(makeChainNode).remove(keyPath);
}
}
}
/**
@module ember
*/
/**
Starts watching a property on an object. Whenever the property changes,
invokes `Ember.notifyPropertyChange`. This is the primitive used by observers
and dependent keys; usually you will never call this method directly but instead
use higher level methods like `addObserver()`.
@private
@method watch
@for Ember
@param obj
@param {String} keyPath
@param {Object} meta
*/
function watch(obj, keyPath, meta$$1) {
if (isPath(keyPath)) {
watchPath(obj, keyPath, meta$$1);
} else {
watchKey(obj, keyPath, meta$$1);
}
}
function isWatching(obj, key) {
return watcherCount(obj, key) > 0;
}
function watcherCount(obj, key) {
let meta$$1 = (0, _meta2.peekMeta)(obj);
return meta$$1 !== undefined && meta$$1.peekWatching(key) || 0;
}
/**
Stops watching a property on an object. Usually you will never call this method directly but instead
use higher level methods like `removeObserver()`.
@private
@method unwatch
@for Ember
@param obj
@param {String} keyPath
@param {Object} meta
*/
function unwatch(obj, keyPath, meta$$1) {
if (isPath(keyPath)) {
unwatchPath(obj, keyPath, meta$$1);
} else {
unwatchKey(obj, keyPath, meta$$1);
}
}
// ..........................................................
// DEPENDENT KEYS
//
function addDependentKeys(desc, obj, keyName, meta$$1) {
// the descriptor has a list of dependent keys, so
// add all of its dependent keys.
let depKeys = desc._dependentKeys;
if (depKeys === null || depKeys === undefined) {
return;
}
for (let idx = 0; idx < depKeys.length; idx++) {
let depKey = depKeys[idx];
// Increment the number of times depKey depends on keyName.
meta$$1.writeDeps(depKey, keyName, meta$$1.peekDeps(depKey, keyName) + 1);
// Watch the depKey
watch(obj, depKey, meta$$1);
}
}
function removeDependentKeys(desc, obj, keyName, meta$$1) {
// the descriptor has a list of dependent keys, so
// remove all of its dependent keys.
let depKeys = desc._dependentKeys;
if (depKeys === null || depKeys === undefined) {
return;
}
for (let idx = 0; idx < depKeys.length; idx++) {
let depKey = depKeys[idx];
// Decrement the number of times depKey depends on keyName.
meta$$1.writeDeps(depKey, keyName, meta$$1.peekDeps(depKey, keyName) - 1);
// Unwatch the depKey
unwatch(obj, depKey, meta$$1);
}
}
/**
@module @ember/object
*/
const END_WITH_EACH_REGEX = /\.@each$/;
/**
Expands `pattern`, invoking `callback` for each expansion.
The only pattern supported is brace-expansion, anything else will be passed
once to `callback` directly.
Example
```js
import { expandProperties } from '@ember/object/computed';
function echo(arg){ console.log(arg); }
expandProperties('foo.bar', echo); //=> 'foo.bar'
expandProperties('{foo,bar}', echo); //=> 'foo', 'bar'
expandProperties('foo.{bar,baz}', echo); //=> 'foo.bar', 'foo.baz'
expandProperties('{foo,bar}.baz', echo); //=> 'foo.baz', 'bar.baz'
expandProperties('foo.{bar,baz}.[]', echo) //=> 'foo.bar.[]', 'foo.baz.[]'
expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
expandProperties('{foo}.bar.{baz}') //=> 'foo.bar.baz'
```
@method expandProperties
@static
@for @ember/object/computed
@public
@param {String} pattern The property pattern to expand.
@param {Function} callback The callback to invoke. It is invoked once per
expansion, and is passed the expansion.
*/
function expandProperties(pattern, callback) {
false && !(typeof pattern === 'string') && (0, _debug.assert)(`A computed property key must be a string, you passed ${typeof pattern} ${pattern}`, typeof pattern === 'string');
false && !(pattern.indexOf(' ') === -1) && (0, _debug.assert)('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1);
// regex to look for double open, double close, or unclosed braces
false && !(pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null) && (0, _debug.assert)(`Brace expanded properties have to be balanced and cannot be nested, pattern: ${pattern}`, pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null);
let start = pattern.indexOf('{');
if (start < 0) {
callback(pattern.replace(END_WITH_EACH_REGEX, '.[]'));
} else {
dive('', pattern, start, callback);
}
}
function dive(prefix, pattern, start, callback) {
let end = pattern.indexOf('}'),
i = 0,
newStart,
arrayLength;
let tempArr = pattern.substring(start + 1, end).split(',');
let after = pattern.substring(end + 1);
prefix = prefix + pattern.substring(0, start);
arrayLength = tempArr.length;
while (i < arrayLength) {
newStart = after.indexOf('{');
if (newStart < 0) {
callback((prefix + tempArr[i++] + after).replace(END_WITH_EACH_REGEX, '.[]'));
} else {
dive(prefix + tempArr[i++], after, newStart, callback);
}
}
}
let setWithMandatorySetter;
let makeEnumerable;
/**
@module @ember/object
*/
/**
Sets the value of a property on an object, respecting computed properties
and notifying observers and other listeners of the change.
If the specified property is not defined on the object and the object
implements the `setUnknownProperty` method, then instead of setting the
value of the property on the object, its `setUnknownProperty` handler
will be invoked with the two parameters `keyName` and `value`.
```javascript
import { set } from '@ember/object';
set(obj, "name", value);
```
@method set
@static
@for @ember/object
@param {Object} obj The object to modify.
@param {String} keyName The property key to set
@param {Object} value The value to set
@return {Object} the passed value.
@public
*/
function set(obj, keyName, value, tolerant) {
false && !(arguments.length === 3 || arguments.length === 4) && (0, _debug.assert)(`Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`, arguments.length === 3 || arguments.length === 4);
false && !(obj && typeof obj === 'object' || typeof obj === 'function') && (0, _debug.assert)(`Cannot call set with '${keyName}' on an undefined object.`, obj && typeof obj === 'object' || typeof obj === 'function');
false && !(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && (0, _debug.assert)(`The key provided to set must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
false && !(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && (0, _debug.assert)(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
if (obj.isDestroyed) {
false && !tolerant && (0, _debug.assert)(`calling set on destroyed object: ${(0, _utils.toString)(obj)}.${keyName} = ${(0, _utils.toString)(value)}`, tolerant);
return;
}
if (isPath(keyName)) {
return setPath(obj, keyName, value, tolerant);
}
let possibleDesc = (0, _meta2.descriptorFor)(obj, keyName);
if (possibleDesc !== undefined) {
/* computed property */
possibleDesc.set(obj, keyName, value);
return value;
}
let currentValue;
if (false /* DEBUG */ && _utils.HAS_NATIVE_PROXY) {
currentValue = getPossibleMandatoryProxyValue(obj, keyName);
} else {
currentValue = obj[keyName];
}
if (currentValue === undefined && 'object' === typeof obj && !(keyName in obj) && typeof obj.setUnknownProperty === 'function') {
/* unknown property */
obj.setUnknownProperty(keyName, value);
} else {
let meta$$1 = (0, _meta2.peekMeta)(obj);
if (false /* DEBUG */) {
setWithMandatorySetter(meta$$1, obj, keyName, value);
} else {
obj[keyName] = value;
}
if (currentValue !== value) {
notifyPropertyChange(obj, keyName, meta$$1);
}
}
return value;
}
if (false /* DEBUG */) {
setWithMandatorySetter = (meta$$1, obj, keyName, value) => {
if (meta$$1 !== undefined && meta$$1.peekWatching(keyName) > 0) {
makeEnumerable(obj, keyName);
meta$$1.writeValue(obj, keyName, value);
} else {
obj[keyName] = value;
}
};
makeEnumerable = (obj, key) => {
let desc = Object.getOwnPropertyDescriptor(obj, key);
if (desc && desc.set && desc.set.isMandatorySetter) {
desc.enumerable = true;
Object.defineProperty(obj, key, desc);
}
};
}
function setPath(root, path, value, tolerant) {
let parts = path.split('.');
let keyName = parts.pop();
false && !(keyName.trim().length > 0) && (0, _debug.assert)('Property set failed: You passed an empty path', keyName.trim().length > 0);
let newPath = parts.join('.');
let newRoot = _getPath(root, newPath);
if (newRoot !== null && newRoot !== undefined) {
return set(newRoot, keyName, value);
} else if (!tolerant) {
throw new _error.default(`Property set failed: object in path "${newPath}" could not be found.`);
}
}
/**
Error-tolerant form of `set`. Will not blow up if any part of the
chain is `undefined`, `null`, or destroyed.
This is primarily used when syncing bindings, which may try to update after
an object has been destroyed.
```javascript
import { trySet } from '@ember/object';
let obj = { name: "Zoey" };
trySet(obj, "contacts.twitter", "@emberjs");
```
@method trySet
@static
@for @ember/object
@param {Object} root The object to modify.
@param {String} path The property path to set
@param {Object} value The value to set
@public
*/
function trySet(root, path, value) {
return set(root, path, value, true);
}
/**
@module @ember/object
*/
const DEEP_EACH_REGEX = /\.@each\.[^.]+\./;
function noop() {}
/**
A computed property transforms an object literal with object's accessor function(s) into a property.
By default the function backing the computed property will only be called
once and the result will be cached. You can specify various properties
that your computed property depends on. This will force the cached
result to be recomputed if the dependencies are modified.
In the following example we declare a computed property - `fullName` - by calling
`computed` with property dependencies (`firstName` and `lastName`) as leading arguments and getter accessor function. The `fullName` getter function
will be called once (regardless of how many times it is accessed) as long
as its dependencies have not changed. Once `firstName` or `lastName` are updated
any future calls (or anything bound) to `fullName` will incorporate the new
values.
```javascript
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
// these will be supplied by `create`
firstName: null,
lastName: null,
fullName: computed('firstName', 'lastName', function() {
let firstName = this.get('firstName'),
lastName = this.get('lastName');
return `${firstName} ${lastName}`;
})
});
let tom = Person.create({
firstName: 'Tom',
lastName: 'Dale'
});
tom.get('fullName') // 'Tom Dale'
```
You can also define what Ember should do when setting a computed property by providing additional function (`set`) in hash argument.
If you try to set a computed property, it will try to invoke setter accessor function with the key and
value you want to set it to as arguments.
```javascript
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
// these will be supplied by `create`
firstName: null,
lastName: null,
fullName: computed('firstName', 'lastName', {
get(key) {
let firstName = this.get('firstName'),
lastName = this.get('lastName');
return firstName + ' ' + lastName;
},
set(key, value) {
let [firstName, lastName] = value.split(' ');
this.set('firstName', firstName);
this.set('lastName', lastName);
return value;
}
})
});
let person = Person.create();
person.set('fullName', 'Peter Wagenet');
person.get('firstName'); // 'Peter'
person.get('lastName'); // 'Wagenet'
```
You can overwrite computed property with normal property (no longer computed), that won't change if dependencies change, if you set computed property and it won't have setter accessor function defined.
You can also mark computed property as `.readOnly()` and block all attempts to set it.
```javascript
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
// these will be supplied by `create`
firstName: null,
lastName: null,
fullName: computed('firstName', 'lastName', {
get(key) {
let firstName = this.get('firstName');
let lastName = this.get('lastName');
return firstName + ' ' + lastName;
}
}).readOnly()
});
let person = Person.create();
person.set('fullName', 'Peter Wagenet'); // Uncaught Error: Cannot set read-only property "fullName" on object: <(...):emberXXX>
```
Additional resources:
- [New CP syntax RFC](https://github.com/emberjs/rfcs/blob/master/text/0011-improved-cp-syntax.md)
- [New computed syntax explained in "Ember 1.12 released" ](https://emberjs.com/blog/2015/05/13/ember-1-12-released.html#toc_new-computed-syntax)
@class ComputedProperty
@public
*/
class ComputedProperty extends Descriptor {
constructor(config, opts) {
super();
let hasGetterOnly = typeof config === 'function';
if (hasGetterOnly) {
this._getter = config;
} else {
const objectConfig = config;
false && !(typeof objectConfig === 'object' && !Array.isArray(objectConfig)) && (0, _debug.assert)('computed expects a function or an object as last argument.', typeof objectConfig === 'object' && !Array.isArray(objectConfig));
false && !Object.keys(objectConfig).every(key => key === 'get' || key === 'set') && (0, _debug.assert)('Config object passed to computed can only contain `get` and `set` keys.', Object.keys(objectConfig).every(key => key === 'get' || key === 'set'));
false && !(!!objectConfig.get || !!objectConfig.set) && (0, _debug.assert)('Computed properties must receive a getter or a setter, you passed none.', !!objectConfig.get || !!objectConfig.set);
this._getter = objectConfig.get || noop;
this._setter = objectConfig.set;
}
this._suspended = undefined;
this._meta = undefined;
this._volatile = false;
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
this._auto = false;
}
this._dependentKeys = opts && opts.dependentKeys;
this._readOnly = !!opts && hasGetterOnly && opts.readOnly === true;
}
/**
Call on a computed property to set it into non-cached mode. When in this
mode the computed property will not automatically cache the return value.
It also does not automatically fire any change events. You must manually notify
any changes if you want to observe this property.
Dependency keys have no effect on volatile properties as they are for cache
invalidation and notification when cached value is invalidated.
```javascript
import EmberObject, { computed } from '@ember/object';
let outsideService = EmberObject.extend({
value: computed(function() {
return OutsideService.getValue();
}).volatile()
}).create();
```
@method volatile
@return {ComputedProperty} this
@chainable
@public
*/
volatile() {
this._volatile = true;
return this;
}
/**
Call on a computed property to set it into read-only mode. When in this
mode the computed property will throw an error when set.
```javascript
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
guid: computed(function() {
return 'guid-guid-guid';
}).readOnly()
});
let person = Person.create();
person.set('guid', 'new-guid'); // will throw an exception
```
@method readOnly
@return {ComputedProperty} this
@chainable
@public
*/
readOnly() {
this._readOnly = true;
false && !!(this._readOnly && this._setter && this._setter !== this._getter) && (0, _debug.assert)('Computed properties that define a setter using the new syntax cannot be read-only', !(this._readOnly && this._setter && this._setter !== this._getter));
return this;
}
/**
Sets the dependent keys on this computed property. Pass any number of
arguments containing key paths that this computed property depends on.
```javascript
import EmberObject, { computed } from '@ember/object';
let President = EmberObject.extend({
fullName: computed('firstName', 'lastName', function() {
return this.get('firstName') + ' ' + this.get('lastName');
// Tell Ember that this computed property depends on firstName
// and lastName
})
});
let president = President.create({
firstName: 'Barack',
lastName: 'Obama'
});
president.get('fullName'); // 'Barack Obama'
```
@method property
@param {String} path* zero or more property paths
@return {ComputedProperty} this
@chainable
@public
*/
property(...passedArgs) {
let args = [];
function addArg(property) {
false && (0, _debug.warn)(`Dependent keys containing @each only work one level deep. ` + `You used the key "${property}" which is invalid. ` + `Please create an intermediary computed property.`, DEEP_EACH_REGEX.test(property) === false, { id: 'ember-metal.computed-deep-each' });
args.push(property);
}
for (let i = 0; i < passedArgs.length; i++) {
expandProperties(passedArgs[i], addArg);
}
this._dependentKeys = args;
return this;
}
/**
In some cases, you may want to annotate computed properties with additional
metadata about how they function or what values they operate on. For example,
computed property functions may close over variables that are then no longer
available for introspection.
You can pass a hash of these values to a computed property like this:
```
import { computed } from '@ember/object';
import Person from 'my-app/utils/person';
person: computed(function() {
let personId = this.get('personId');
return Person.create({ id: personId });
}).meta({ type: Person })
```
The hash that you pass to the `meta()` function will be saved on the
computed property descriptor under the `_meta` key. Ember runtime
exposes a public API for retrieving these values from classes,
via the `metaForProperty()` function.
@method meta
@param {Object} meta
@chainable
@public
*/
meta(meta$$1) {
if (arguments.length === 0) {
return this._meta || {};
} else {
this._meta = meta$$1;
return this;
}
}
// invalidate cache when CP key changes
didChange(obj, keyName) {
// _suspended is set via a CP.set to ensure we don't clear
// the cached value set by the setter
if (this._volatile || this._suspended === obj) {
return;
}
// don't create objects just to invalidate
let meta$$1 = (0, _meta2.peekMeta)(obj);
if (meta$$1 === undefined || meta$$1.source !== obj) {
return;
}
let cache = peekCacheFor(obj);
if (cache !== undefined && cache.delete(keyName)) {
removeDependentKeys(this, obj, keyName, meta$$1);
}
}
get(obj, keyName) {
if (this._volatile) {
return this._getter.call(obj, keyName);
}
let cache = getCacheFor(obj);
let propertyTag;
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
propertyTag = tagForProperty(obj, keyName);
if (cache.has(keyName)) {
// special-case for computed with no dependent keys used to
// trigger cacheable behavior.
if (!this._auto && (!this._dependentKeys || this._dependentKeys.length === 0)) {
return cache.get(keyName);
}
let lastRevision = getLastRevisionFor(obj, keyName);
if (propertyTag.validate(lastRevision)) {
return cache.get(keyName);
}
}
} else {
if (cache.has(keyName)) {
return cache.get(keyName);
}
}
let parent;
let tracker;
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
parent = getCurrentTracker();
tracker = setCurrentTracker();
}
let ret = this._getter.call(obj, keyName);
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
setCurrentTracker(parent);
let tag = tracker.combine();
if (parent) parent.add(tag);
update(propertyTag, tag);
setLastRevisionFor(obj, keyName, propertyTag.value());
}
cache.set(keyName, ret);
let meta$$1 = (0, _meta2.meta)(obj);
let chainWatchers = meta$$1.readableChainWatchers();
if (chainWatchers !== undefined) {
chainWatchers.revalidate(keyName);
}
addDependentKeys(this, obj, keyName, meta$$1);
return ret;
}
set(obj, keyName, value) {
if (this._readOnly) {
this._throwReadOnlyError(obj, keyName);
}
if (!this._setter) {
return this.clobberSet(obj, keyName, value);
}
if (this._volatile) {
return this.volatileSet(obj, keyName, value);
}
return this.setWithSuspend(obj, keyName, value);
}
_throwReadOnlyError(obj, keyName) {
throw new _error.default(`Cannot set read-only property "${keyName}" on object: ${(0, _utils.inspect)(obj)}`);
}
clobberSet(obj, keyName, value) {
let cachedValue = getCachedValueFor(obj, keyName);
defineProperty(obj, keyName, null, cachedValue);
set(obj, keyName, value);
return value;
}
volatileSet(obj, keyName, value) {
return this._setter.call(obj, keyName, value);
}
setWithSuspend(obj, keyName, value) {
let oldSuspended = this._suspended;
this._suspended = obj;
try {
return this._set(obj, keyName, value);
} finally {
this._suspended = oldSuspended;
}
}
_set(obj, keyName, value) {
let cache = getCacheFor(obj);
let hadCachedValue = cache.has(keyName);
let cachedValue = cache.get(keyName);
let ret = this._setter.call(obj, keyName, value, cachedValue);
// allows setter to return the same value that is cached already
if (hadCachedValue && cachedValue === ret) {
return ret;
}
let meta$$1 = (0, _meta2.meta)(obj);
if (!hadCachedValue) {
addDependentKeys(this, obj, keyName, meta$$1);
}
cache.set(keyName, ret);
notifyPropertyChange(obj, keyName, meta$$1);
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
let propertyTag = tagForProperty(obj, keyName);
setLastRevisionFor(obj, keyName, propertyTag.value());
}
return ret;
}
/* called before property is overridden */
teardown(obj, keyName, meta$$1) {
if (!this._volatile) {
let cache = peekCacheFor(obj);
if (cache !== undefined && cache.delete(keyName)) {
removeDependentKeys(this, obj, keyName, meta$$1);
}
}
super.teardown(obj, keyName, meta$$1);
}
}
if (false /* EMBER_METAL_TRACKED_PROPERTIES */) {
ComputedProperty.prototype.auto = function () {
this._auto = true;
return this;
};
}
/**
This helper returns a new property descriptor that wraps the passed
computed property function. You can use this helper to define properties
with mixins or via `defineProperty()`.
If you pass a function as an argument, it will be used as a getter. A computed
property defined in this way might look like this:
```js
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
init() {
this._super(...arguments);
this.firstName = 'Betty';
this.lastName = 'Jones';
},
fullName: computed('firstName', 'lastName', function() {
return `${this.get('firstName')} ${this.get('lastName')}`;
})
});
let client = Person.create();
client.get('fullName'); // 'Betty Jones'
client.set('lastName', 'Fuller');
client.get('fullName'); // 'Betty Fuller'
```
You can pass a hash with two functions, `get` and `set`, as an
argument to provide both a getter and setter:
```js
import EmberObject, { computed } from '@ember/object';
let Person = EmberObject.extend({
init() {
this._super(...arguments);
this.firstName = 'Betty';
this.lastName = 'Jones';
},
fullName: computed('firstName', 'lastName', {
get(key) {
return `${this.get('firstName')} ${this.get('lastName')}`;
},
set(key, value) {
let [firstName, lastName] = value.split(/\s+/);
this.setProperties({ firstName, lastName });
return value;
}
})
});
let client = Person.create();
client.get('firstName'); // 'Betty'
client.set('fullName', 'Carroll Fuller');
client.get('firstName'); // 'Carroll'
```
The `set` function should accept two parameters, `key` and `value`. The value
returned from `set` will be the new value of the property.
_Note: This is the preferred way to define computed properties when writing third-party
libraries that depend on or use Ember, since there is no guarantee that the user
will have [prototype Extensions](https://guides.emberjs.com/release/configuring-ember/disabling-prototype-extensions/) enabled._
The alternative syntax, with prototype extensions, might look like:
```js
fullName: function() {
return this.get('firstName') + ' ' + this.get('lastName');
}.property('firstName', 'lastName')
```
@method computed
@for @ember/object
@static
@param {String} [dependentKeys*] Optional dependent keys that trigger this computed property.
@param {Function} func The computed property function.
@return {ComputedProperty} property descriptor instance
@public
*/
function computed(...args) {
let func = args.pop();
let cp = new ComputedProperty(func);
if (args.length > 0) {
cp.property(...args);
}
return cp;
}
// used for the Ember.computed global only
const _globalsComputed = computed.bind(null);
const CONSUMED = Object.freeze({});
function alias(altKey) {
return new AliasedProperty(altKey);
}
class AliasedProperty extends Descriptor {
constructor(altKey) {
super();
this.altKey = altKey;
this._dependentKeys = [altKey];
}
setup(obj, keyName, meta$$1) {
false && !(this.altKey !== keyName) && (0, _debug.assert)(`Setting alias '${keyName}' on self`, this.altKey !== keyName);
super.setup(obj, keyName, meta$$1);
if (meta$$1.peekWatching(keyName) > 0) {
this.consume(obj, keyName, meta$$1);
}
}
teardown(obj, keyName, meta$$1) {
this.unconsume(obj, keyName, meta$$1);
super.teardown(obj, keyName, meta$$1);
}
willWatch(obj, keyName, meta$$1) {
this.consume(obj, keyName, meta$$1);
}
didUnwatch(obj, keyName, meta$$1) {
this.unconsume(obj, keyName, meta$$1);
}
get(obj, keyName) {
let ret = get(obj, this.altKey);
this.consume(obj, keyName, (0, _meta2.meta)(obj));
return ret;
}
unconsume(obj, keyName, meta$$1) {
let wasConsumed = getCachedValueFor(obj, keyName) === CONSUMED;
if (wasConsumed || meta$$1.peekWatching(keyName) > 0) {
removeDependentKeys(this, obj, keyName, meta$$1);
}
if (wasConsumed) {
getCacheFor(obj).delete(keyName);
}
}
consume(obj, keyName, meta$$1) {
let cache = getCacheFor(obj);
if (cache.get(keyName) !== CONSUMED) {
cache.set(keyName, CONSUMED);
addDependentKeys(this, obj, keyName, meta$$1);
}
}
set(obj, _keyName, value) {
return set(obj, this.altKey, value);
}
readOnly() {
this.set = AliasedProperty_readOnlySet;
return this;
}
oneWay() {
this.set = AliasedProperty_oneWaySet;
return this;
}
}
function AliasedProperty_readOnlySet(obj, keyName) {
// eslint-disable-line no-unused-vars
throw new _error.default(`Cannot set read-only property '${keyName}' on object: ${(0, _utils.inspect)(obj)}`);
}
function AliasedProperty_oneWaySet(obj, keyName, value) {
defineProperty(obj, keyName, null);
return set(obj, keyName, value);
}
// Backwards compatibility with Ember Data.
AliasedProperty.prototype._meta = undefined;
AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
/**
@module ember
*/
/**
Used internally to allow changing properties in a backwards compatible way, and print a helpful
deprecation warning.
@method deprecateProperty
@param {Object} object The object to add the deprecated property to.
@param {String} deprecatedKey The property to add (and print deprecation warnings upon accessing).
@param {String} newKey The property that will be aliased.
@private
@since 1.7.0
*/
function deprecateProperty(object, deprecatedKey, newKey, options) {
function _deprecate() {
false && !false && (0, _debug.deprecate)(`Usage of \`${deprecatedKey}\` is deprecated, use \`${newKey}\` instead.`, false, options);
}
Object.defineProperty(object, deprecatedKey, {
configurable: true,
enumerable: false,
set(value) {
_deprecate();
set(this, newKey, value);
},
get() {
_deprecate();
return get(this, newKey);
}
});
}
/**
@module @ember/utils
*/
/**
Returns true if the passed value is null or undefined. This avoids errors
from JSLint complaining about use of ==, which can be technically
confusing.
```javascript
isNone(); // true
isNone(null); // true
isNone(undefined); // true
isNone(''); // false
isNone([]); // false
isNone(function() {}); // false
```
@method isNone
@static
@for @ember/utils
@param {Object} obj Value to test
@return {Boolean}
@public
*/
function isNone(obj) {
return obj === null || obj === undefined;
}
/**
@module @ember/utils
*/
/**
Verifies that a value is `null` or `undefined`, an empty string, or an empty
array.
Constrains the rules on `isNone` by returning true for empty strings and
empty arrays.
If the value is an object with a `size` property of type number, it is used
to check emptiness.
```javascript
isEmpty(); // true
isEmpty(null); // true
isEmpty(undefined); // true
isEmpty(''); // true
isEmpty([]); // true
isEmpty({ size: 0}); // true
isEmpty({}); // false
isEmpty('Adam Hawkins'); // false
isEmpty([0,1,2]); // false
isEmpty('\n\t'); // false
isEmpty(' '); // false
isEmpty({ size: 1 }) // false
isEmpty({ size: () => 0 }) // false
```
@method isEmpty
@static
@for @ember/utils
@param {Object} obj Value to test
@return {Boolean}
@public
*/
function isEmpty(obj) {
let none = obj === null || obj === undefined;
if (none) {
return none;
}
if (typeof obj.size === 'number') {
return !obj.size;
}
let objectType = typeof obj;
if (objectType === 'object') {
let size = get(obj, 'size');
if (typeof size === 'number') {
return !size;
}
}
if (typeof obj.length === 'number' && objectType !== 'function') {
return !obj.length;
}
if (objectType === 'object') {
let length = get(obj, 'length');
if (typeof length === 'number') {
return !length;
}
}
return false;
}
/**
@module @ember/utils
*/
/**
A value is blank if it is empty or a whitespace string.
```javascript
import { isBlank } from '@ember/utils';
isBlank(); // true
isBlank(null); // true
isBlank(undefined); // true
isBlank(''); // true
isBlank([]); // true
isBlank('\n\t'); // true
isBlank(' '); // true
isBlank({}); // false
isBlank('\n\t Hello'); // false
isBlank('Hello world'); // false
isBlank([1,2,3]); // false
```
@method isBlank
@static
@for @ember/utils
@param {Object} obj Value to test
@return {Boolean}
@since 1.5.0
@public
*/
function isBlank(obj) {
return isEmpty(obj) || typeof obj === 'string' && /\S/.test(obj) === false;
}
/**
@module @ember/utils
*/
/**
A value is present if it not `isBlank`.
```javascript
isPresent(); // false
isPresent(null); // false
isPresent(undefined); // false
isPresent(''); // false
isPresent(' '); // false
isPresent('\n\t'); // false
isPresent([]); // false
isPresent({ length: 0 }); // false
isPresent(false); // true
isPresent(true); // true
isPresent('string'); // true
isPresent(0); // true
isPresent(function() {}); // true
isPresent({}); // true
isPresent('\n\t Hello'); // true
isPresent([1, 2, 3]); // true
```
@method isPresent
@static
@for @ember/utils
@param {Object} obj Value to test
@return {Boolean}
@since 1.8.0
@public
*/
function isPresent(obj) {
return !isBlank(obj);
}
/**
@module ember
*/
/**
Helper class that allows you to register your library with Ember.
Singleton created at `Ember.libraries`.
@class Libraries
@constructor
@private
*/
class Libraries {
constructor() {
this._registry = [];
this._coreLibIndex = 0;
}
_getLibraryByName(name) {
let libs = this._registry;
let count = libs.length;
for (let i = 0; i < count; i++) {
if (libs[i].name === name) {
return libs[i];
}
}
return undefined;
}
register(name, version, isCoreLibrary) {
let index = this._registry.length;
if (!this._getLibraryByName(name)) {
if (isCoreLibrary) {
index = this._coreLibIndex++;
}
this._registry.splice(index, 0, { name, version });
} else {
false && (0, _debug.warn)(`Library "${name}" is already registered with Ember.`, false, {
id: 'ember-metal.libraries-register'
});
}
}
registerCoreLibrary(name, version) {
this.register(name, version, true);
}
deRegister(name) {
let lib = this._getLibraryByName(name);
let index;
if (lib) {
index = this._registry.indexOf(lib);
this._registry.splice(index, 1);
}
}
}
if (false /* EMBER_LIBRARIES_ISREGISTERED */) {
Libraries.prototype.isRegistered = function (name) {
return !!this._getLibraryByName(name);
};
}
if (false /* DEBUG */) {
Libraries.prototype.logVersions = function () {
let libs = this._registry;
let nameLengths = libs.map(item => get(item, 'name.length'));
let maxNameLength = Math.max.apply(null, nameLengths);
(0, _debug.debug)('-------------------------------');
for (let i = 0; i < libs.length; i++) {
let lib = libs[i];
let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
(0, _debug.debug)([lib.name, spaces, ' : ', lib.version].join(''));
}
(0, _debug.debug)('-------------------------------');
};
}
const LIBRARIES = new Libraries();
LIBRARIES.registerCoreLibrary('Ember', _version.default);
/**
@module @ember/object
*/
/**
To get multiple properties at once, call `getProperties`
with an object followed by a list of strings or an array:
```javascript
import { getProperties } from '@ember/object';
getProperties(record, 'firstName', 'lastName', 'zipCode');
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
```
is equivalent to:
```javascript
import { getProperties } from '@ember/object';
getProperties(record, ['firstName', 'lastName', 'zipCode']);
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
```
@method getProperties
@static
@for @ember/object
@param {Object} obj
@param {String...|Array} list of keys to get
@return {Object}
@public
*/
function getProperties(obj, keys) {
let ret = {};
let propertyNames = arguments;
let i = 1;
if (arguments.length === 2 && Array.isArray(keys)) {
i = 0;
propertyNames = arguments[1];
}
for (; i < propertyNames.length; i++) {
ret[propertyNames[i]] = get(obj, propertyNames[i]);
}
return ret;
}
/**
@module @ember/object
*/
/**
Set a list of properties on an object. These properties are set inside
a single `beginPropertyChanges` and `endPropertyChanges` batch, so
observers will be buffered.
```javascript
import EmberObject from '@ember/object';
let anObject = EmberObject.create();
anObject.setProperties({
firstName: 'Stanley',
lastName: 'Stuart',
age: 21
});
```
@method setProperties
@static
@for @ember/object
@param obj
@param {Object} properties
@return properties
@public
*/
function setProperties(obj, properties) {
if (properties === null || typeof properties !== 'object') {
return properties;
}
changeProperties(() => {
let props = Object.keys(properties);
let propertyName;
for (let i = 0; i < props.length; i++) {
propertyName = props[i];
set(obj, propertyName, properties[propertyName]);
}
});
return properties;
}
// TODO, this only depends on context, otherwise it could be in utils
// move into its own package
// it is needed by Mixin for classToString
// maybe move it into environment
const hasOwnProperty = Object.prototype.hasOwnProperty;
let searchDisabled = false;
const flags = {
_set: 0,
_unprocessedNamespaces: false,
get unprocessedNamespaces() {
return this._unprocessedNamespaces;
},
set unprocessedNamespaces(v) {
this._set++;
this._unprocessedNamespaces = v;
}
};
let unprocessedMixins = false;
const NAMESPACES = [];
const NAMESPACES_BY_ID = Object.create(null);
function addNamespace(namespace) {
flags.unprocessedNamespaces = true;
NAMESPACES.push(namespace);
}
function removeNamespace(namespace) {
let name = (0, _utils.getName)(namespace);
delete NAMESPACES_BY_ID[name];
NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
if (name in _environment.context.lookup && namespace === _environment.context.lookup[name]) {
_environment.context.lookup[name] = undefined;
}
}
function findNamespaces() {
if (!flags.unprocessedNamespaces) {
return;
}
let lookup = _environment.context.lookup;
let keys = Object.keys(lookup);
for (let i = 0; i < keys.length; i++) {
let key = keys[i];
// Only process entities that start with uppercase A-Z
if (!isUppercase(key.charCodeAt(0))) {
continue;
}
let obj = tryIsNamespace(lookup, key);
if (obj) {
(0, _utils.setName)(obj, key);
}
}
}
function findNamespace(name) {
if (!searchDisabled) {
processAllNamespaces();
}
return NAMESPACES_BY_ID[name];
}
function processNamespace(namespace) {
_processNamespace([namespace.toString()], namespace, new Set());
}
function processAllNamespaces() {
let unprocessedNamespaces = flags.unprocessedNamespaces;
if (unprocessedNamespaces) {
findNamespaces();
flags.unprocessedNamespaces = false;
}
if (unprocessedNamespaces || unprocessedMixins) {
let namespaces = NAMESPACES;
for (let i = 0; i < namespaces.length; i++) {
processNamespace(namespaces[i]);
}
unprocessedMixins = false;
}
}
function classToString() {
let name = (0, _utils.getName)(this);
if (name !== void 0) {
return name;
}
name = calculateToString(this);
(0, _utils.setName)(this, name);
return name;
}
function isSearchDisabled() {
return searchDisabled;
}
function setSearchDisabled(flag) {
searchDisabled = !!flag;
}
function setUnprocessedMixins() {
unprocessedMixins = true;
}
function _processNamespace(paths, root, seen) {
let idx = paths.length;
let id = paths.join('.');
NAMESPACES_BY_ID[id] = root;
(0, _utils.setName)(root, id);
// Loop over all of the keys in the namespace, looking for classes
for (let key in root) {
if (!hasOwnProperty.call(root, key)) {
continue;
}
let obj = root[key];
// If we are processing the `Ember` namespace, for example, the
// `paths` will start with `["Ember"]`. Every iteration through
// the loop will update the **second** element of this list with
// the key, so processing `Ember.View` will make the Array
// `['Ember', 'View']`.
paths[idx] = key;
// If we have found an unprocessed class
if (obj && obj.toString === classToString && (0, _utils.getName)(obj) === void 0) {
// Replace the class' `toString` with the dot-separated path
(0, _utils.setName)(obj, paths.join('.'));
// Support nested namespaces
} else if (obj && obj.isNamespace) {
// Skip aliased namespaces
if (seen.has(obj)) {
continue;
}
seen.add(obj);
// Process the child namespace
_processNamespace(paths, obj, seen);
}
}
paths.length = idx; // cut out last item
}
function isUppercase(code) {
return code >= 65 && code <= 90 // A
; // Z
}
function tryIsNamespace(lookup, prop) {
try {
let obj = lookup[prop];
return (obj !== null && typeof obj === 'object' || typeof obj === 'function') && obj.isNamespace && obj;
} catch (e) {
// continue
}
}
function calculateToString(target) {
let str;
if (!searchDisabled) {
processAllNamespaces();
str = (0, _utils.getName)(target);
if (str !== void 0) {
return str;
}
let superclass = target;
do {
superclass = Object.getPrototypeOf(superclass);
if (superclass === Function.prototype || superclass === Object.prototype) {
break;
}
str = (0, _utils.getName)(target);
if (str !== void 0) {
str = `(subclass of ${str})`;
break;
}
} while (str === void 0);
}
return str || '(unknown)';
}
/**
@module @ember/object
*/
const a_concat = Array.prototype.concat;
const { isArray } = Array;
function isMethod(obj) {
return 'function' === typeof obj && obj.isMethod !== false && obj !== Boolean && obj !== Object && obj !== Number && obj !== Array && obj !== Date && obj !== String;
}
const CONTINUE = {};
function mixinProperties(mixinsMeta, mixin) {
if (mixin instanceof Mixin) {
if (mixinsMeta.hasMixin(mixin)) {
return CONTINUE;
}
mixinsMeta.addMixin(mixin);
return mixin.properties;
} else {
return mixin; // apply anonymous mixin properties
}
}
function concatenatedMixinProperties(concatProp, props, values, base) {
// reset before adding each new mixin to pickup concats from previous
let concats = values[concatProp] || base[concatProp];
if (props[concatProp]) {
concats = concats ? a_concat.call(concats, props[concatProp]) : props[concatProp];
}
return concats;
}
function giveDescriptorSuper(meta$$1, key, property, values, descs, base) {
let superProperty;
// Computed properties override methods, and do not call super to them
if (values[key] === undefined) {
// Find the original descriptor in a parent mixin
superProperty = descs[key];
}
// If we didn't find the original descriptor in a parent mixin, find
// it on the original object.
if (!superProperty) {
superProperty = (0, _meta2.descriptorFor)(base, key, meta$$1);
}
if (superProperty === undefined || !(superProperty instanceof ComputedProperty)) {
return property;
}
// Since multiple mixins may inherit from the same parent, we need
// to clone the computed property so that other mixins do not receive
// the wrapped version.
property = Object.create(property);
property._getter = (0, _utils.wrap)(property._getter, superProperty._getter);
if (superProperty._setter) {
if (property._setter) {
property._setter = (0, _utils.wrap)(property._setter, superProperty._setter);
} else {
property._setter = superProperty._setter;
}
}
return property;
}
function giveMethodSuper(obj, key, method, values, descs) {
// Methods overwrite computed properties, and do not call super to them.
if (descs[key] !== undefined) {
return method;
}
// Find the original method in a parent mixin
let superMethod = values[key];
// If we didn't find the original value in a parent mixin, find it in
// the original object
if (superMethod === undefined && (0, _meta2.descriptorFor)(obj, key) === undefined) {
superMethod = obj[key];
}
// Only wrap the new method if the original method was a function
if (typeof superMethod === 'function') {
return (0, _utils.wrap)(method, superMethod);
}
return method;
}
function applyConcatenatedProperties(obj, key, value, values) {
let baseValue = values[key] || obj[key];
let ret = (0, _utils.makeArray)(baseValue).concat((0, _utils.makeArray)(value));
if (false /* DEBUG */) {
// it is possible to use concatenatedProperties with strings (which cannot be frozen)
// only freeze objects...
if (typeof ret === 'object' && ret !== null) {
// prevent mutating `concatenatedProperties` array after it is applied
Object.freeze(ret);
}
}
return ret;
}
function applyMergedProperties(obj, key, value, values) {
let baseValue = values[key] || obj[key];
false && !!isArray(value) && (0, _debug.assert)(`You passed in \`${JSON.stringify(value)}\` as the value for \`${key}\` but \`${key}\` cannot be an Array`, !isArray(value));
if (!baseValue) {
return value;
}
let newBase = (0, _polyfills.assign)({}, baseValue);
let hasFunction = false;
for (let prop in value) {
if (!value.hasOwnProperty(prop)) {
continue;
}
let propValue = value[prop];
if (isMethod(propValue)) {
// TODO: support for Computed Properties, etc?
hasFunction = true;
newBase[prop] = giveMethodSuper(obj, prop, propValue, baseValue, {});
} else {
newBase[prop] = propValue;
}
}
if (hasFunction) {
newBase._super = _utils.ROOT;
}
return newBase;
}
function addNormalizedProperty(base, key, value, meta$$1, descs, values, concats, mergings) {
if (value instanceof Descriptor) {
// Wrap descriptor function to implement
// _super() if needed
if (value._getter) {
value = giveDescriptorSuper(meta$$1, key, value, values, descs, base);
}
descs[key] = value;
values[key] = undefined;
} else {
if (concats && concats.indexOf(key) >= 0 || key === 'concatenatedProperties' || key === 'mergedProperties') {
value = applyConcatenatedProperties(base, key, value, values);
} else if (mergings && mergings.indexOf(key) > -1) {
value = applyMergedProperties(base, key, value, values);
} else if (isMethod(value)) {
value = giveMethodSuper(base, key, value, values, descs);
}
descs[key] = undefined;
values[key] = value;
}
}
function mergeMixins(mixins, meta$$1, descs, values, base, keys) {
let currentMixin, props, key, concats, mergings;
function removeKeys(keyName) {
delete descs[keyName];
delete values[keyName];
}
for (let i = 0; i < mixins.length; i++) {
currentMixin = mixins[i];
false && !(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && (0, _debug.assert)(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(currentMixin)}`, typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
props = mixinProperties(meta$$1, currentMixin);
if (props === CONTINUE) {
continue;
}
if (props) {
// remove willMergeMixin after 3.4 as it was used for _actions
if (base.willMergeMixin) {
base.willMergeMixin(props);
}
concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
for (key in props) {
if (!props.hasOwnProperty(key)) {
continue;
}
keys.push(key);
addNormalizedProperty(base, key, props[key], meta$$1, descs, values, concats, mergings);
}
// manually copy toString() because some JS engines do not enumerate it
if (props.hasOwnProperty('toString')) {
base.toString = props.toString;
}
} else if (currentMixin.mixins) {
mergeMixins(currentMixin.mixins, meta$$1, descs, values, base, keys);
if (currentMixin._without) {
currentMixin._without.forEach(removeKeys);
}
}
}
}
function followAlias(obj, desc, descs, values) {
let altKey = desc.methodName;
let value;
let possibleDesc;
if (descs[altKey] || values[altKey]) {
value = values[altKey];
desc = descs[altKey];
} else if ((possibleDesc = (0, _meta2.descriptorFor)(obj, altKey)) !== undefined) {
desc = possibleDesc;
value = undefined;
} else {
desc = undefined;
value = obj[altKey];
}
return { desc, value };
}
function updateObserversAndListeners(obj, key, paths, updateMethod) {
if (paths) {
for (let i = 0; i < paths.length; i++) {
updateMethod(obj, paths[i], null, key);
}
}
}
function replaceObserversAndListeners(obj, key, prev, next) {
if (typeof prev === 'function') {
updateObserversAndListeners(obj, key, (0, _utils.getObservers)(prev), removeObserver);
updateObserversAndListeners(obj, key, (0, _utils.getListeners)(prev), removeListener);
}
if (typeof next === 'function') {
updateObserversAndListeners(obj, key, (0, _utils.getObservers)(next), addObserver);
updateObserversAndListeners(obj, key, (0, _utils.getListeners)(next), addListener);
}
}
function applyMixin(obj, mixins) {
let descs = {};
let values = {};
let meta$$1 = (0, _meta2.meta)(obj);
let keys = [];
let key, value, desc;
obj._super = _utils.ROOT;
// Go through all mixins and hashes passed in, and:
//
// * Handle concatenated properties
// * Handle merged properties
// * Set up _super wrapping if necessary
// * Set up computed property descriptors
// * Copying `toString` in broken browsers
mergeMixins(mixins, meta$$1, descs, values, obj, keys);
for (let i = 0; i < keys.length; i++) {
key = keys[i];
if (key === 'constructor' || !values.hasOwnProperty(key)) {
continue;
}
desc = descs[key];
value = values[key];
while (desc && desc instanceof Alias) {
let followed = followAlias(obj, desc, descs, values);
desc = followed.desc;
value = followed.value;
}
if (desc === undefined && value === undefined) {
continue;
}
if ((0, _meta2.descriptorFor)(obj, key) !== undefined) {
replaceObserversAndListeners(obj, key, null, value);
} else {
replaceObserversAndListeners(obj, key, obj[key], value);
}
defineProperty(obj, key, desc, value, meta$$1);
}
return obj;
}
/**
@method mixin
@param obj
@param mixins*
@return obj
@private
*/
function mixin(obj, ...args) {
applyMixin(obj, args);
return obj;
}
/**
The `Mixin` class allows you to create mixins, whose properties can be
added to other classes. For instance,
```javascript
import Mixin from '@ember/object/mixin';
const EditableMixin = Mixin.create({
edit() {
console.log('starting to edit');
this.set('isEditing', true);
},
isEditing: false
});
```
```javascript
import EmberObject from '@ember/object';
import EditableMixin from '../mixins/editable';
// Mix mixins into classes by passing them as the first arguments to
// `.extend.`
const Comment = EmberObject.extend(EditableMixin, {
post: null
});
let comment = Comment.create({
post: somePost
});
comment.edit(); // outputs 'starting to edit'
```
Note that Mixins are created with `Mixin.create`, not
`Mixin.extend`.
Note that mixins extend a constructor's prototype so arrays and object literals
defined as properties will be shared amongst objects that implement the mixin.
If you want to define a property in a mixin that is not shared, you can define
it either as a computed property or have it be created on initialization of the object.
```javascript
// filters array will be shared amongst any object implementing mixin
import Mixin from '@ember/object/mixin';
import { A } from '@ember/array';
const FilterableMixin = Mixin.create({
filters: A()
});
```
```javascript
import Mixin from '@ember/object/mixin';
import { A } from '@ember/array';
import { computed } from '@ember/object';
// filters will be a separate array for every object implementing the mixin
const FilterableMixin = Mixin.create({
filters: computed(function() {
return A();
})
});
```
```javascript
import Mixin from '@ember/object/mixin';
import { A } from '@ember/array';
// filters will be created as a separate array during the object's initialization
const Filterable = Mixin.create({
filters: null,
init() {
this._super(...arguments);
this.set("filters", A());
}
});
```
@class Mixin
@public
*/
class Mixin {
constructor(mixins, properties) {
this.properties = properties;
this.mixins = buildMixinsArray(mixins);
this.ownerConstructor = undefined;
this._without = undefined;
if (false /* DEBUG */) {
this[_utils.NAME_KEY] = undefined;
/*
In debug builds, we seal mixins to help avoid performance pitfalls.
In IE11 there is a quirk that prevents sealed objects from being added
to a WeakMap. Unfortunately, the mixin system currently relies on
weak maps in `guidFor`, so we need to prime the guid cache weak map.
*/
(0, _utils.guidFor)(this);
Object.seal(this);
}
}
/**
@method create
@for @ember/object/mixin
@static
@param arguments*
@public
*/
static create(...args) {
// ES6TODO: this relies on a global state?
setUnprocessedMixins();
let M = this;
return new M(args, undefined);
}
// returns the mixins currently applied to the specified object
// TODO: Make `mixin`
static mixins(obj) {
let meta$$1 = (0, _meta2.peekMeta)(obj);
let ret = [];
if (meta$$1 === undefined) {
return ret;
}
meta$$1.forEachMixins(currentMixin => {
// skip primitive mixins since these are always anonymous
if (!currentMixin.properties) {
ret.push(currentMixin);
}
});
return ret;
}
/**
@method reopen
@param arguments*
@private
*/
reopen(...args) {
if (args.length === 0) {
return;
}
if (this.properties) {
let currentMixin = new Mixin(undefined, this.properties);
this.properties = undefined;
this.mixins = [currentMixin];
} else if (!this.mixins) {
this.mixins = [];
}
this.mixins = this.mixins.concat(buildMixinsArray(args));
return this;
}
/**
@method apply
@param obj
@return applied object
@private
*/
apply(obj) {
return applyMixin(obj, [this]);
}
applyPartial(obj) {
return applyMixin(obj, [this]);
}
/**
@method detect
@param obj
@return {Boolean}
@private
*/
detect(obj) {
if (typeof obj !== 'object' || obj === null) {
return false;
}
if (obj instanceof Mixin) {
return _detect(obj, this);
}
let meta$$1 = (0, _meta2.peekMeta)(obj);
if (meta$$1 === undefined) {
return false;
}
return meta$$1.hasMixin(this);
}
without(...args) {
let ret = new Mixin([this]);
ret._without = args;
return ret;
}
keys() {
return _keys(this);
}
toString() {
return '(unknown mixin)';
}
}
function buildMixinsArray(mixins) {
let length = mixins && mixins.length || 0;
let m = undefined;
if (length > 0) {
m = new Array(length);
for (let i = 0; i < length; i++) {
let x = mixins[i];
false && !(typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]') && (0, _debug.assert)(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(x)}`, typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]');
if (x instanceof Mixin) {
m[i] = x;
} else {
m[i] = new Mixin(undefined, x);
}
}
}
return m;
}
Mixin.prototype.toString = classToString;
if (false /* DEBUG */) {
Mixin.prototype[_utils.NAME_KEY] = undefined;
Object.seal(Mixin.prototype);
}
function _detect(curMixin, targetMixin, seen = new Set()) {
if (seen.has(curMixin)) {
return false;
}
seen.add(curMixin);
if (curMixin === targetMixin) {
return true;
}
let mixins = curMixin.mixins;
if (mixins) {
return mixins.some(mixin => _detect(mixin, targetMixin, seen));
}
return false;
}
function _keys(mixin, ret = new Set(), seen = new Set()) {
if (seen.has(mixin)) {
return;
}
seen.add(mixin);
if (mixin.properties) {
let props = Object.keys(mixin.properties);
for (let i = 0; i < props.length; i++) {
ret.add(props[i]);
}
} else if (mixin.mixins) {
mixin.mixins.forEach(x => _keys(x, ret, seen));
}
return ret;
}
class Alias extends Descriptor {
constructor(methodName) {
super();
this.methodName = methodName;
}
teardown(_obj, _keyName, _meta) {
throw new Error('Method not implemented.');
}
get(_obj, _keyName) {
throw new Error('Method not implemented.');
}
set(_obj, _keyName, _value) {
throw new Error('Method not implemented.');
}
}
/**
Makes a method available via an additional name.
```app/utils/person.js
import EmberObject, {
aliasMethod
} from '@ember/object';
export default EmberObject.extend({
name() {
return 'Tomhuda Katzdale';
},
moniker: aliasMethod('name')
});
```
```javascript
let goodGuy = Person.create();
goodGuy.name(); // 'Tomhuda Katzdale'
goodGuy.moniker(); // 'Tomhuda Katzdale'
```
@method aliasMethod
@static
@for @ember/object
@param {String} methodName name of the method to alias
@public
*/
function aliasMethod(methodName) {
return new Alias(methodName);
}
// ..........................................................
// OBSERVER HELPER
//
/**
Specify a method that observes property changes.
```javascript
import EmberObject from '@ember/object';
import { observer } from '@ember/object';
export default EmberObject.extend({
valueObserver: observer('value', function() {
// Executes whenever the "value" property changes
})
});
```
Also available as `Function.prototype.observes` if prototype extensions are
enabled.
@method observer
@for @ember/object
@param {String} propertyNames*
@param {Function} func
@return func
@public
@static
*/
function observer(...args) {
let func = args.pop();
let _paths = args;
false && !(typeof func === 'function') && (0, _debug.assert)('observer called without a function', typeof func === 'function');
false && !(_paths.length > 0 && _paths.every(p => typeof p === 'string' && !!p.length)) && (0, _debug.assert)('observer called without valid path', _paths.length > 0 && _paths.every(p => typeof p === 'string' && !!p.length));
let paths = [];
let addWatchedProperty = path => paths.push(path);
for (let i = 0; i < _paths.length; ++i) {
expandProperties(_paths[i], addWatchedProperty);
}
(0, _utils.setObservers)(func, paths);
return func;
}
/**
@module ember
@private
*/
/**
Read-only property that returns the result of a container lookup.
@class InjectedProperty
@namespace Ember
@constructor
@param {String} type The container type the property will lookup
@param {String} name (optional) The name the property will lookup, defaults
to the property's name
@private
*/
class InjectedProperty extends ComputedProperty {
constructor(type, name, options) {
super(injectedPropertyGet);
this.type = type;
this.name = name;
if (false /* EMBER_MODULE_UNIFICATION */) {
this.source = options ? options.source : undefined;
this.namespace = undefined;
if (name) {
let namespaceDelimiterOffset = name.indexOf('::');
if (namespaceDelimiterOffset === -1) {
this.name = name;
this.namespace = undefined;
} else {
this.name = name.slice(namespaceDelimiterOffset + 2);
this.namespace = name.slice(0, namespaceDelimiterOffset);
}
}
}
}
}
function injectedPropertyGet(keyName) {
let desc = (0, _meta2.descriptorFor)(this, keyName);
let owner = (0, _owner.getOwner)(this) || this.container; // fallback to `container` for backwards compat
false && !(desc && desc.type) && (0, _debug.assert)(`InjectedProperties should be defined with the inject computed property macros.`, desc && desc.type);
false && !!!owner && (0, _debug.assert)(`Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`, !!owner);
let specifier = `${desc.type}:${desc.name || keyName}`;
return owner.lookup(specifier, {
source: desc.source,
namespace: desc.namespace
});
}
function descriptor(desc) {
return new NativeDescriptor(desc);
}
/**
A wrapper for a native ES5 descriptor. In an ideal world, we wouldn't need
this at all, however, the way we currently flatten/merge our mixins require
a special value to denote a descriptor.
@class NativeDescriptor
@private
*/
class NativeDescriptor extends Descriptor {
constructor(desc) {
super();
this.desc = desc;
this.enumerable = desc.enumerable !== false;
this.configurable = desc.configurable !== false;
}
setup(obj, key, meta$$1) {
Object.defineProperty(obj, key, this.desc);
meta$$1.writeDescriptors(key, this);
}
get(obj, key) {
return obj[key];
}
set(obj, key, value) {
return obj[key] = value;
}
}
exports.computed = computed;
exports.ComputedProperty = ComputedProperty;
exports._globalsComputed = _globalsComputed;
exports.getCacheFor = getCacheFor;
exports.getCachedValueFor = getCachedValueFor;
exports.peekCacheFor = peekCacheFor;
exports.alias = alias;
exports.deprecateProperty = deprecateProperty;
exports.PROXY_CONTENT = PROXY_CONTENT;
exports._getPath = _getPath;
exports.get = get;
exports.getWithDefault = getWithDefault;
exports.set = set;
exports.trySet = trySet;
exports.objectAt = objectAt;
exports.replace = replace;
exports.replaceInNativeArray = replaceInNativeArray;
exports.addArrayObserver = addArrayObserver;
exports.removeArrayObserver = removeArrayObserver;
exports.arrayContentWillChange = arrayContentWillChange;
exports.arrayContentDidChange = arrayContentDidChange;
exports.eachProxyFor = eachProxyFor;
exports.eachProxyArrayWillChange = eachProxyArrayWillChange;
exports.eachProxyArrayDidChange = eachProxyArrayDidChange;
exports.addListener = addListener;
exports.hasListeners = hasListeners;
exports.on = on;
exports.removeListener = removeListener;
exports.sendEvent = sendEvent;
exports.isNone = isNone;
exports.isEmpty = isEmpty;
exports.isBlank = isBlank;
exports.isPresent = isPresent;
exports.beginPropertyChanges = beginPropertyChanges;
exports.changeProperties = changeProperties;
exports.endPropertyChanges = endPropertyChanges;
exports.notifyPropertyChange = notifyPropertyChange;
exports.overrideChains = overrideChains;
exports.PROPERTY_DID_CHANGE = PROPERTY_DID_CHANGE;
exports.defineProperty = defineProperty;
exports.Descriptor = Descriptor;
exports.watchKey = watchKey;
exports.unwatchKey = unwatchKey;
exports.ChainNode = ChainNode;
exports.finishChains = finishChains;
exports.removeChainWatcher = removeChainWatcher;
exports.watchPath = watchPath;
exports.unwatchPath = unwatchPath;
exports.isWatching = isWatching;
exports.unwatch = unwatch;
exports.watch = watch;
exports.watcherCount = watcherCount;
exports.libraries = LIBRARIES;
exports.Libraries = Libraries;
exports.getProperties = getProperties;
exports.setProperties = setProperties;
exports.expandProperties = expandProperties;
exports.addObserver = addObserver;
exports.removeObserver = removeObserver;
exports.Mixin = Mixin;
exports.aliasMethod = aliasMethod;
exports.mixin = mixin;
exports.observer = observer;
exports.applyMixin = applyMixin;
exports.InjectedProperty = InjectedProperty;
exports.setHasViews = setHasViews;
exports.tagForProperty = tagForProperty;
exports.tagFor = tagFor;
exports.markObjectAsDirty = markObjectAsDirty;
exports.runInTransaction = runInTransaction;
exports.didRender = didRender;
exports.assertNotRendered = assertNotRendered;
exports.descriptor = descriptor;
exports.tracked = tracked;
exports.NAMESPACES = NAMESPACES;
exports.NAMESPACES_BY_ID = NAMESPACES_BY_ID;
exports.addNamespace = addNamespace;
exports.classToString = classToString;
exports.findNamespace = findNamespace;
exports.findNamespaces = findNamespaces;
exports.processNamespace = processNamespace;
exports.processAllNamespaces = processAllNamespaces;
exports.removeNamespace = removeNamespace;
exports.isNamespaceSearchDisabled = isSearchDisabled;
exports.setNamespaceSearchDisabled = setSearchDisabled;
});
enifed('@ember/-internals/owner/index', ['exports', '@ember/-internals/utils'], function (exports, _utils) {
'use strict';
exports.OWNER = undefined;
exports.getOwner = getOwner;
exports.setOwner = setOwner;
const OWNER = exports.OWNER = (0, _utils.symbol)('OWNER');
/**
Framework objects in an Ember application (components, services, routes, etc.)
are created via a factory and dependency injection system. Each of these
objects is the responsibility of an "owner", which handled its
instantiation and manages its lifetime.
`getOwner` fetches the owner object responsible for an instance. This can
be used to lookup or resolve other class instances, or register new factories
into the owner.
For example, this component dynamically looks up a service based on the
`audioType` passed as an attribute:
```app/components/play-audio.js
import Component from '@ember/component';
import { computed } from '@ember/object';
import { getOwner } from '@ember/application';
// Usage:
//
// {{play-audio audioType=model.audioType audioFile=model.file}}
//
export default Component.extend({
audioService: computed('audioType', function() {
let owner = getOwner(this);
return owner.lookup(`service:${this.get('audioType')}`);
}),
click() {
let player = this.get('audioService');
player.play(this.get('audioFile'));
}
});
```
@method getOwner
@static
@for @ember/application
@param {Object} object An object with an owner.
@return {Object} An owner object.
@since 2.3.0
@public
*/
/**
@module @ember/application
*/
function getOwner(object) {
return object[OWNER];
}
/**
`setOwner` forces a new owner on a given object instance. This is primarily
useful in some testing cases.
@method setOwner
@static
@for @ember/application
@param {Object} object An object instance.
@param {Object} object The new owner object of the object instance.
@since 2.3.0
@public
*/
function setOwner(object, owner) {
object[OWNER] = owner;
}
});
enifed('@ember/-internals/routing/index', ['exports', '@ember/-internals/routing/lib/location/api', '@ember/-internals/routing/lib/location/none_location', '@ember/-internals/routing/lib/location/hash_location', '@ember/-internals/routing/lib/location/history_location', '@ember/-internals/routing/lib/location/auto_location', '@ember/-internals/routing/lib/system/generate_controller', '@ember/-internals/routing/lib/system/controller_for', '@ember/-internals/routing/lib/system/dsl', '@ember/-internals/routing/lib/system/router', '@ember/-internals/routing/lib/system/route', '@ember/-internals/routing/lib/system/query_params', '@ember/-internals/routing/lib/services/routing', '@ember/-internals/routing/lib/services/router', '@ember/-internals/routing/lib/system/cache', '@ember/-internals/routing/lib/ext/controller'], function (exports, _api, _none_location, _hash_location, _history_location, _auto_location, _generate_controller, _controller_for, _dsl, _router, _route, _query_params, _routing, _router2, _cache) {
'use strict';
exports.BucketCache = exports.RouterService = exports.RoutingService = exports.QueryParams = exports.Route = exports.Router = exports.RouterDSL = exports.controllerFor = exports.generateControllerFactory = exports.generateController = exports.AutoLocation = exports.HistoryLocation = exports.HashLocation = exports.NoneLocation = exports.Location = undefined;
Object.defineProperty(exports, 'Location', {
enumerable: true,
get: function () {
return _api.default;
}
});
Object.defineProperty(exports, 'NoneLocation', {
enumerable: true,
get: function () {
return _none_location.default;
}
});
Object.defineProperty(exports, 'HashLocation', {
enumerable: true,
get: function () {
return _hash_location.default;
}
});
Object.defineProperty(exports, 'HistoryLocation', {
enumerable: true,
get: function () {
return _history_location.default;
}
});
Object.defineProperty(exports, 'AutoLocation', {
enumerable: true,
get: function () {
return _auto_location.default;
}
});
Object.defineProperty(exports, 'generateController', {
enumerable: true,
get: function () {
return _generate_controller.default;
}
});
Object.defineProperty(exports, 'generateControllerFactory', {
enumerable: true,
get: function () {
return _generate_controller.generateControllerFactory;
}
});
Object.defineProperty(exports, 'controllerFor', {
enumerable: true,
get: function () {
return _controller_for.default;
}
});
Object.defineProperty(exports, 'RouterDSL', {
enumerable: true,
get: function () {
return _dsl.default;
}
});
Object.defineProperty(exports, 'Router', {
enumerable: true,
get: function () {
return _router.default;
}
});
Object.defineProperty(exports, 'Route', {
enumerable: true,
get: function () {
return _route.default;
}
});
Object.defineProperty(exports, 'QueryParams', {
enumerable: true,
get: function () {
return _query_params.default;
}
});
Object.defineProperty(exports, 'RoutingService', {
enumerable: true,
get: function () {
return _routing.default;
}
});
Object.defineProperty(exports, 'RouterService', {
enumerable: true,
get: function () {
return _router2.default;
}
});
Object.defineProperty(exports, 'BucketCache', {
enumerable: true,
get: function () {
return _cache.default;
}
});
});
enifed('@ember/-internals/routing/lib/ext/controller', ['exports', '@ember/-internals/metal', '@ember/controller/lib/controller_mixin', '@ember/-internals/routing/lib/utils'], function (exports, _metal, _controller_mixin, _utils) {
'use strict';
/**
@module ember
*/
_controller_mixin.default.reopen({
concatenatedProperties: ['queryParams'],
/**
Defines which query parameters the controller accepts.
If you give the names `['category','page']` it will bind
the values of these query parameters to the variables
`this.category` and `this.page`.
By default, Ember coerces query parameter values using `toggleProperty`.
This behavior may lead to unexpected results.
To explicitly configure a query parameter property so it coerces as expected, you must define a type property:
```javascript
queryParams: [{
category: {
type: 'boolean'
}
}]
```
@for Ember.ControllerMixin
@property queryParams
@public
*/
queryParams: null,
/**
This property is updated to various different callback functions depending on
the current "state" of the backing route. It is used by
`Controller.prototype._qpChanged`.
The methods backing each state can be found in the `Route.prototype._qp` computed
property return value (the `.states` property). The current values are listed here for
the sanity of future travelers:
* `inactive` - This state is used when this controller instance is not part of the active
route hierarchy. Set in `Route.prototype._reset` (a `router.js` microlib hook) and
`Route.prototype.actions.finalizeQueryParamChange`.
* `active` - This state is used when this controller instance is part of the active
route hierarchy. Set in `Route.prototype.actions.finalizeQueryParamChange`.
* `allowOverrides` - This state is used in `Route.prototype.setup` (`route.js` microlib hook).
@method _qpDelegate
@private
*/
_qpDelegate: null,
/**
During `Route#setup` observers are created to invoke this method
when any of the query params declared in `Controller#queryParams` property
are changed.
When invoked this method uses the currently active query param update delegate
(see `Controller.prototype._qpDelegate` for details) and invokes it with
the QP key/value being changed.
@method _qpChanged
@private
*/
_qpChanged(controller, _prop) {
let prop = _prop.substr(0, _prop.length - 3);
let delegate = controller._qpDelegate;
let value = (0, _metal.get)(controller, prop);
delegate(prop, value);
},
/**
Transition the application into another route. The route may
be either a single route or route path:
```javascript
aController.transitionToRoute('blogPosts');
aController.transitionToRoute('blogPosts.recentEntries');
```
Optionally supply a model for the route in question. The model
will be serialized into the URL using the `serialize` hook of
the route:
```javascript
aController.transitionToRoute('blogPost', aPost);
```
If a literal is passed (such as a number or a string), it will
be treated as an identifier instead. In this case, the `model`
hook of the route will be triggered:
```javascript
aController.transitionToRoute('blogPost', 1);
```
Multiple models will be applied last to first recursively up the
route tree.
```app/router.js
Router.map(function() {
this.route('blogPost', { path: ':blogPostId' }, function() {
this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
});
});
```
```javascript
aController.transitionToRoute('blogComment', aPost, aComment);
aController.transitionToRoute('blogComment', 1, 13);
```
It is also possible to pass a URL (a string that starts with a
`/`).
```javascript
aController.transitionToRoute('/');
aController.transitionToRoute('/blog/post/1/comment/13');
aController.transitionToRoute('/blog/posts?sort=title');
```
An options hash with a `queryParams` property may be provided as
the final argument to add query parameters to the destination URL.
```javascript
aController.transitionToRoute('blogPost', 1, {
queryParams: { showComments: 'true' }
});
// if you just want to transition the query parameters without changing the route
aController.transitionToRoute({ queryParams: { sort: 'date' } });
```
See also [replaceRoute](/api/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
@param {String} name the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used
while transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@for Ember.ControllerMixin
@method transitionToRoute
@public
*/
transitionToRoute(...args) {
// target may be either another controller or a router
let target = (0, _metal.get)(this, 'target');
let method = target.transitionToRoute || target.transitionTo;
return method.apply(target, (0, _utils.prefixRouteNameArg)(this, args));
},
/**
Transition into another route while replacing the current URL, if possible.
This will replace the current history entry instead of adding a new one.
Beside that, it is identical to `transitionToRoute` in all other respects.
```javascript
aController.replaceRoute('blogPosts');
aController.replaceRoute('blogPosts.recentEntries');
```
Optionally supply a model for the route in question. The model
will be serialized into the URL using the `serialize` hook of
the route:
```javascript
aController.replaceRoute('blogPost', aPost);
```
If a literal is passed (such as a number or a string), it will
be treated as an identifier instead. In this case, the `model`
hook of the route will be triggered:
```javascript
aController.replaceRoute('blogPost', 1);
```
Multiple models will be applied last to first recursively up the
route tree.
```app/router.js
Router.map(function() {
this.route('blogPost', { path: ':blogPostId' }, function() {
this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
});
});
```
```
aController.replaceRoute('blogComment', aPost, aComment);
aController.replaceRoute('blogComment', 1, 13);
```
It is also possible to pass a URL (a string that starts with a
`/`).
```javascript
aController.replaceRoute('/');
aController.replaceRoute('/blog/post/1/comment/13');
```
@param {String} name the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used
while transitioning to the route.
@for Ember.ControllerMixin
@method replaceRoute
@public
*/
replaceRoute(...args) {
// target may be either another controller or a router
let target = (0, _metal.get)(this, 'target');
let method = target.replaceRoute || target.replaceWith;
return method.apply(target, (0, _utils.prefixRouteNameArg)(this, args));
}
});
exports.default = _controller_mixin.default;
});
enifed('@ember/-internals/routing/lib/location/api', ['exports', '@ember/-internals/browser-environment', '@ember/debug'], function (exports, _browserEnvironment, _debug) {
'use strict';
exports.default = {
/**
This is deprecated in favor of using the container to lookup the location
implementation as desired.
For example:
```javascript
// Given a location registered as follows:
container.register('location:history-test', HistoryTestLocation);
// You could create a new instance via:
container.lookup('location:history-test');
```
@method create
@param {Object} options
@return {Object} an instance of an implementation of the `location` API
@deprecated Use the container to lookup the location implementation that you
need.
@private
*/
create(options) {
let implementation = options && options.implementation;
false && !!!implementation && (0, _debug.assert)("Location.create: you must specify a 'implementation' option", !!implementation);
let implementationClass = this.implementations[implementation];
false && !!!implementationClass && (0, _debug.assert)(`Location.create: ${implementation} is not a valid implementation`, !!implementationClass);
return implementationClass.create(...arguments);
},
implementations: {},
_location: _browserEnvironment.location
};
});
enifed('@ember/-internals/routing/lib/location/auto_location', ['exports', '@ember/-internals/browser-environment', '@ember/-internals/metal', '@ember/-internals/owner', '@ember/-internals/runtime', '@ember/-internals/utils', '@ember/debug', '@ember/-internals/routing/lib/location/util'], function (exports, _browserEnvironment, _metal, _owner, _runtime, _utils, _debug, _util) {
'use strict';
exports.getHistoryPath = getHistoryPath;
exports.getHashPath = getHashPath;
/**
@module @ember/routing
*/
/**
AutoLocation will select the best location option based off browser
support with the priority order: history, hash, none.
Clean pushState paths accessed by hashchange-only browsers will be redirected
to the hash-equivalent and vice versa so future transitions are consistent.
Keep in mind that since some of your users will use `HistoryLocation`, your
server must serve the Ember app at all the routes you define.
Browsers that support the `history` API will use `HistoryLocation`, those that
do not, but still support the `hashchange` event will use `HashLocation`, and
in the rare case neither is supported will use `NoneLocation`.
Example:
```app/router.js
Router.map(function() {
this.route('posts', function() {
this.route('new');
});
});
Router.reopen({
location: 'auto'
});
```
This will result in a posts.new url of `/posts/new` for modern browsers that
support the `history` api or `/#/posts/new` for older ones, like Internet
Explorer 9 and below.
When a user visits a link to your application, they will be automatically
upgraded or downgraded to the appropriate `Location` class, with the URL
transformed accordingly, if needed.
Keep in mind that since some of your users will use `HistoryLocation`, your
server must serve the Ember app at all the routes you define.
@class AutoLocation
@static
@protected
*/
class AutoLocation extends _runtime.Object {
constructor() {
super(...arguments);
this.implementation = 'auto';
}
/**
Called by the router to instruct the location to do any feature detection
necessary. In the case of AutoLocation, we detect whether to use history
or hash concrete implementations.
@private
*/
detect() {
let rootURL = this.rootURL;
false && !(rootURL.charAt(rootURL.length - 1) === '/') && (0, _debug.assert)('rootURL must end with a trailing forward slash e.g. "/app/"', rootURL.charAt(rootURL.length - 1) === '/');
let implementation = detectImplementation({
location: this.location,
history: this.history,
userAgent: this.userAgent,
rootURL,
documentMode: this.documentMode,
global: this.global
});
if (implementation === false) {
(0, _metal.set)(this, 'cancelRouterSetup', true);
implementation = 'none';
}
let concrete = (0, _owner.getOwner)(this).lookup(`location:${implementation}`);
(0, _metal.set)(concrete, 'rootURL', rootURL);
false && !!!concrete && (0, _debug.assert)(`Could not find location '${implementation}'.`, !!concrete);
(0, _metal.set)(this, 'concreteImplementation', concrete);
}
willDestroy() {
let concreteImplementation = (0, _metal.get)(this, 'concreteImplementation');
if (concreteImplementation) {
concreteImplementation.destroy();
}
}
}
exports.default = AutoLocation;
AutoLocation.reopen({
/**
@private
Will be pre-pended to path upon state change.
@since 1.5.1
@property rootURL
@default '/'
*/
rootURL: '/',
initState: delegateToConcreteImplementation('initState'),
getURL: delegateToConcreteImplementation('getURL'),
setURL: delegateToConcreteImplementation('setURL'),
replaceURL: delegateToConcreteImplementation('replaceURL'),
onUpdateURL: delegateToConcreteImplementation('onUpdateURL'),
formatURL: delegateToConcreteImplementation('formatURL'),
/**
@private
The browser's `location` object. This is typically equivalent to
`window.location`, but may be overridden for testing.
@property location
@default environment.location
*/
location: _browserEnvironment.location,
/**
@private
The browser's `history` object. This is typically equivalent to
`window.history`, but may be overridden for testing.
@since 1.5.1
@property history
@default environment.history
*/
history: _browserEnvironment.history,
/**
@private
The user agent's global variable. In browsers, this will be `window`.
@since 1.11
@property global
@default window
*/
global: _browserEnvironment.window,
/**
@private
The browser's `userAgent`. This is typically equivalent to
`navigator.userAgent`, but may be overridden for testing.
@since 1.5.1
@property userAgent
@default environment.history
*/
userAgent: _browserEnvironment.userAgent,
/**
@private
This property is used by the router to know whether to cancel the routing
setup process, which is needed while we redirect the browser.
@since 1.5.1
@property cancelRouterSetup
@default false
*/
cancelRouterSetup: false
});
function delegateToConcreteImplementation(methodName) {
return function (...args) {
let concreteImplementation = (0, _metal.get)(this, 'concreteImplementation');
false && !!!concreteImplementation && (0, _debug.assert)("AutoLocation's detect() method should be called before calling any other hooks.", !!concreteImplementation);
return (0, _utils.tryInvoke)(concreteImplementation, methodName, args);
};
}
function detectImplementation(options) {
let { location, userAgent, history, documentMode, global, rootURL } = options;
let implementation = 'none';
let cancelRouterSetup = false;
let currentPath = (0, _util.getFullPath)(location);
if ((0, _util.supportsHistory)(userAgent, history)) {
let historyPath = getHistoryPath(rootURL, location);
// If the browser supports history and we have a history path, we can use
// the history location with no redirects.
if (currentPath === historyPath) {
implementation = 'history';
} else if (currentPath.substr(0, 2) === '/#') {
history.replaceState({ path: historyPath }, undefined, historyPath);
implementation = 'history';
} else {
cancelRouterSetup = true;
(0, _util.replacePath)(location, historyPath);
}
} else if ((0, _util.supportsHashChange)(documentMode, global)) {
let hashPath = getHashPath(rootURL, location);
// Be sure we're using a hashed path, otherwise let's switch over it to so
// we start off clean and consistent. We'll count an index path with no
// hash as "good enough" as well.
if (currentPath === hashPath || currentPath === '/' && hashPath === '/#/') {
implementation = 'hash';
} else {
// Our URL isn't in the expected hash-supported format, so we want to
// cancel the router setup and replace the URL to start off clean
cancelRouterSetup = true;
(0, _util.replacePath)(location, hashPath);
}
}
if (cancelRouterSetup) {
return false;
}
return implementation;
}
/**
@private
Returns the current path as it should appear for HistoryLocation supported
browsers. This may very well differ from the real current path (e.g. if it
starts off as a hashed URL)
*/
function getHistoryPath(rootURL, location) {
let path = (0, _util.getPath)(location);
let hash = (0, _util.getHash)(location);
let query = (0, _util.getQuery)(location);
let rootURLIndex = path.indexOf(rootURL);
let routeHash, hashParts;
false && !(rootURLIndex === 0) && (0, _debug.assert)(`Path ${path} does not start with the provided rootURL ${rootURL}`, rootURLIndex === 0);
// By convention, Ember.js routes using HashLocation are required to start
// with `#/`. Anything else should NOT be considered a route and should
// be passed straight through, without transformation.
if (hash.substr(0, 2) === '#/') {
// There could be extra hash segments after the route
hashParts = hash.substr(1).split('#');
// The first one is always the route url
routeHash = hashParts.shift();
// If the path already has a trailing slash, remove the one
// from the hashed route so we don't double up.
if (path.charAt(path.length - 1) === '/') {
routeHash = routeHash.substr(1);
}
// This is the "expected" final order
path += routeHash + query;
if (hashParts.length) {
path += `#${hashParts.join('#')}`;
}
} else {
path += query + hash;
}
return path;
}
/**
@private
Returns the current path as it should appear for HashLocation supported
browsers. This may very well differ from the real current path.
@method _getHashPath
*/
function getHashPath(rootURL, location) {
let path = rootURL;
let historyPath = getHistoryPath(rootURL, location);
let routePath = historyPath.substr(rootURL.length);
if (routePath !== '') {
if (routePath[0] !== '/') {
routePath = `/${routePath}`;
}
path += `#${routePath}`;
}
return path;
}
});
enifed('@ember/-internals/routing/lib/location/hash_location', ['exports', '@ember/-internals/metal', '@ember/runloop', '@ember/-internals/runtime', '@ember/-internals/routing/lib/location/util'], function (exports, _metal, _runloop, _runtime, _util) {
'use strict';
/**
@module @ember/routing
*/
/**
`HashLocation` implements the location API using the browser's
hash. At present, it relies on a `hashchange` event existing in the
browser.
Using `HashLocation` results in URLs with a `#` (hash sign) separating the
server side URL portion of the URL from the portion that is used by Ember.
Example:
```app/router.js
Router.map(function() {
this.route('posts', function() {
this.route('new');
});
});
Router.reopen({
location: 'hash'
});
```
This will result in a posts.new url of `/#/posts/new`.
@class HashLocation
@extends EmberObject
@protected
*/
class HashLocation extends _runtime.Object {
constructor() {
super(...arguments);
this.implementation = 'hash';
}
init() {
(0, _metal.set)(this, 'location', (0, _metal.get)(this, '_location') || window.location);
this._hashchangeHandler = undefined;
}
/**
@private
Returns normalized location.hash
@since 1.5.1
@method getHash
*/
getHash() {
return (0, _util.getHash)((0, _metal.get)(this, 'location'));
}
/**
Returns the normalized URL, constructed from `location.hash`.
e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
By convention, hashed paths must begin with a forward slash, otherwise they
are not treated as a path so we can distinguish intent.
@private
@method getURL
*/
getURL() {
let originalPath = this.getHash().substr(1);
let outPath = originalPath;
if (outPath[0] !== '/') {
outPath = '/';
// Only add the # if the path isn't empty.
// We do NOT want `/#` since the ampersand
// is only included (conventionally) when
// the location.hash has a value
if (originalPath) {
outPath += `#${originalPath}`;
}
}
return outPath;
}
/**
Set the `location.hash` and remembers what was set. This prevents
`onUpdateURL` callbacks from triggering when the hash was set by
`HashLocation`.
@private
@method setURL
@param path {String}
*/
setURL(path) {
(0, _metal.get)(this, 'location').hash = path;
(0, _metal.set)(this, 'lastSetURL', path);
}
/**
Uses location.replace to update the url without a page reload
or history modification.
@private
@method replaceURL
@param path {String}
*/
replaceURL(path) {
(0, _metal.get)(this, 'location').replace(`#${path}`);
(0, _metal.set)(this, 'lastSetURL', path);
}
/**
Register a callback to be invoked when the hash changes. These
callbacks will execute when the user presses the back or forward
button, but not after `setURL` is invoked.
@private
@method onUpdateURL
@param callback {Function}
*/
onUpdateURL(callback) {
this._removeEventListener();
this._hashchangeHandler = (0, _runloop.bind)(this, function () {
let path = this.getURL();
if ((0, _metal.get)(this, 'lastSetURL') === path) {
return;
}
(0, _metal.set)(this, 'lastSetURL', null);
callback(path);
});
window.addEventListener('hashchange', this._hashchangeHandler);
}
/**
Given a URL, formats it to be placed into the page as part
of an element's `href` attribute.
This is used, for example, when using the {{action}} helper
to generate a URL based on an event.
@private
@method formatURL
@param url {String}
*/
formatURL(url) {
return `#${url}`;
}
/**
Cleans up the HashLocation event listener.
@private
@method willDestroy
*/
willDestroy() {
this._removeEventListener();
}
_removeEventListener() {
if (this._hashchangeHandler) {
window.removeEventListener('hashchange', this._hashchangeHandler);
}
}
}
exports.default = HashLocation;
});
enifed('@ember/-internals/routing/lib/location/history_location', ['exports', '@ember/-internals/metal', '@ember/-internals/runtime', '@ember/-internals/routing/lib/location/util'], function (exports, _metal, _runtime, _util) {
'use strict';
/**
@module @ember/routing
*/
let popstateFired = false;
function _uuid() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
let r, v;
r = Math.random() * 16 | 0;
v = c === 'x' ? r : r & 3 | 8;
return v.toString(16);
});
}
/**
HistoryLocation implements the location API using the browser's
history.pushState API.
Using `HistoryLocation` results in URLs that are indistinguishable from a
standard URL. This relies upon the browser's `history` API.
Example:
```app/router.js
Router.map(function() {
this.route('posts', function() {
this.route('new');
});
});
Router.reopen({
location: 'history'
});
```
This will result in a posts.new url of `/posts/new`.
Keep in mind that your server must serve the Ember app at all the routes you
define.
@class HistoryLocation
@extends EmberObject
@protected
*/
class HistoryLocation extends _runtime.Object {
constructor() {
super(...arguments);
this.implementation = 'history';
/**
Will be pre-pended to path upon state change
@property rootURL
@default '/'
@private
*/
this.rootURL = '/';
}
/**
@private
Returns normalized location.hash
@method getHash
*/
getHash() {
return (0, _util.getHash)((0, _metal.get)(this, 'location'));
}
init() {
this._super(...arguments);
let base = document.querySelector('base');
let baseURL = '';
if (base) {
baseURL = base.getAttribute('href');
}
(0, _metal.set)(this, 'baseURL', baseURL);
(0, _metal.set)(this, 'location', (0, _metal.get)(this, 'location') || window.location);
this._popstateHandler = undefined;
}
/**
Used to set state on first call to setURL
@private
@method initState
*/
initState() {
let history = (0, _metal.get)(this, 'history') || window.history;
(0, _metal.set)(this, 'history', history);
if (history && 'state' in history) {
this.supportsHistory = true;
}
let state = this.getState();
let path = this.formatURL(this.getURL());
if (state && state.path === path) {
// preserve existing state
// used for webkit workaround, since there will be no initial popstate event
this._previousURL = this.getURL();
} else {
this.replaceState(path);
}
}
/**
Returns the current `location.pathname` without `rootURL` or `baseURL`
@private
@method getURL
@return url {String}
*/
getURL() {
let location = (0, _metal.get)(this, 'location');
let path = location.pathname;
let rootURL = (0, _metal.get)(this, 'rootURL');
let baseURL = (0, _metal.get)(this, 'baseURL');
// remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
baseURL = baseURL.replace(/\/$/, '');
// remove baseURL and rootURL from start of path
let url = path.replace(new RegExp(`^${baseURL}(?=/|$)`), '').replace(new RegExp(`^${rootURL}(?=/|$)`), '').replace(/\/\/$/g, '/'); // remove extra slashes
let search = location.search || '';
url += search + this.getHash();
return url;
}
/**
Uses `history.pushState` to update the url without a page reload.
@private
@method setURL
@param path {String}
*/
setURL(path) {
let state = this.getState();
path = this.formatURL(path);
if (!state || state.path !== path) {
this.pushState(path);
}
}
/**
Uses `history.replaceState` to update the url without a page reload
or history modification.
@private
@method replaceURL
@param path {String}
*/
replaceURL(path) {
let state = this.getState();
path = this.formatURL(path);
if (!state || state.path !== path) {
this.replaceState(path);
}
}
/**
Get the current `history.state`. Checks for if a polyfill is
required and if so fetches this._historyState. The state returned
from getState may be null if an iframe has changed a window's
history.
The object returned will contain a `path` for the given state as well
as a unique state `id`. The state index will allow the app to distinguish
between two states with similar paths but should be unique from one another.
@private
@method getState
@return state {Object}
*/
getState() {
if (this.supportsHistory) {
return (0, _metal.get)(this, 'history').state;
}
return this._historyState;
}
/**
Pushes a new state.
@private
@method pushState
@param path {String}
*/
pushState(path) {
let state = { path, uuid: _uuid() };
(0, _metal.get)(this, 'history').pushState(state, null, path);
this._historyState = state;
// used for webkit workaround
this._previousURL = this.getURL();
}
/**
Replaces the current state.
@private
@method replaceState
@param path {String}
*/
replaceState(path) {
let state = { path, uuid: _uuid() };
(0, _metal.get)(this, 'history').replaceState(state, null, path);
this._historyState = state;
// used for webkit workaround
this._previousURL = this.getURL();
}
/**
Register a callback to be invoked whenever the browser
history changes, including using forward and back buttons.
@private
@method onUpdateURL
@param callback {Function}
*/
onUpdateURL(callback) {
this._removeEventListener();
this._popstateHandler = () => {
// Ignore initial page load popstate event in Chrome
if (!popstateFired) {
popstateFired = true;
if (this.getURL() === this._previousURL) {
return;
}
}
callback(this.getURL());
};
window.addEventListener('popstate', this._popstateHandler);
}
/**
Used when using `{{action}}` helper. The url is always appended to the rootURL.
@private
@method formatURL
@param url {String}
@return formatted url {String}
*/
formatURL(url) {
let rootURL = (0, _metal.get)(this, 'rootURL');
let baseURL = (0, _metal.get)(this, 'baseURL');
if (url !== '') {
// remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
baseURL = baseURL.replace(/\/$/, '');
} else if (baseURL[0] === '/' && rootURL[0] === '/') {
// if baseURL and rootURL both start with a slash
// ... remove trailing slash from baseURL if it exists
baseURL = baseURL.replace(/\/$/, '');
}
return baseURL + rootURL + url;
}
/**
Cleans up the HistoryLocation event listener.
@private
@method willDestroy
*/
willDestroy() {
this._removeEventListener();
}
_removeEventListener() {
if (this._popstateHandler) {
window.removeEventListener('popstate', this._popstateHandler);
}
}
}
exports.default = HistoryLocation;
});
enifed('@ember/-internals/routing/lib/location/none_location', ['exports', '@ember/-internals/metal', '@ember/-internals/runtime', '@ember/debug'], function (exports, _metal, _runtime, _debug) {
'use strict';
/**
@module @ember/routing
*/
/**
NoneLocation does not interact with the browser. It is useful for
testing, or when you need to manage state with your Router, but temporarily
don't want it to muck with the URL (for example when you embed your
application in a larger page).
Using `NoneLocation` causes Ember to not store the applications URL state
in the actual URL. This is generally used for testing purposes, and is one
of the changes made when calling `App.setupForTesting()`.
@class NoneLocation
@extends EmberObject
@protected
*/
class NoneLocation extends _runtime.Object {
constructor() {
super(...arguments);
this.implementation = 'none';
}
detect() {
let rootURL = this.rootURL;
false && !(rootURL.charAt(rootURL.length - 1) === '/') && (0, _debug.assert)('rootURL must end with a trailing forward slash e.g. "/app/"', rootURL.charAt(rootURL.length - 1) === '/');
}
/**
Returns the current path without `rootURL`.
@private
@method getURL
@return {String} path
*/
getURL() {
let path = (0, _metal.get)(this, 'path');
let rootURL = (0, _metal.get)(this, 'rootURL');
// remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
// remove rootURL from url
return path.replace(new RegExp(`^${rootURL}(?=/|$)`), '');
}
/**
Set the path and remembers what was set. Using this method
to change the path will not invoke the `updateURL` callback.
@private
@method setURL
@param path {String}
*/
setURL(path) {
(0, _metal.set)(this, 'path', path);
}
/**
Register a callback to be invoked when the path changes. These
callbacks will execute when the user presses the back or forward
button, but not after `setURL` is invoked.
@private
@method onUpdateURL
@param callback {Function}
*/
onUpdateURL(callback) {
this.updateCallback = callback;
}
/**
Sets the path and calls the `updateURL` callback.
@private
@method handleURL
@param url {String}
*/
handleURL(url) {
(0, _metal.set)(this, 'path', url);
this.updateCallback(url);
}
/**
Given a URL, formats it to be placed into the page as part
of an element's `href` attribute.
This is used, for example, when using the {{action}} helper
to generate a URL based on an event.
@private
@method formatURL
@param url {String}
@return {String} url
*/
formatURL(url) {
let rootURL = (0, _metal.get)(this, 'rootURL');
if (url !== '') {
// remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
}
return rootURL + url;
}
}
exports.default = NoneLocation;
NoneLocation.reopen({
path: '',
/**
Will be pre-pended to path.
@private
@property rootURL
@default '/'
*/
rootURL: '/'
});
});
enifed('@ember/-internals/routing/lib/location/util', ['exports'], function (exports) {
'use strict';
exports.getPath = getPath;
exports.getQuery = getQuery;
exports.getHash = getHash;
exports.getFullPath = getFullPath;
exports.getOrigin = getOrigin;
exports.supportsHashChange = supportsHashChange;
exports.supportsHistory = supportsHistory;
exports.replacePath = replacePath;
/**
@private
Returns the current `location.pathname`, normalized for IE inconsistencies.
*/
function getPath(location) {
let pathname = location.pathname;
// Various versions of IE/Opera don't always return a leading slash
if (pathname[0] !== '/') {
pathname = `/${pathname}`;
}
return pathname;
}
/**
@private
Returns the current `location.search`.
*/
function getQuery(location) {
return location.search;
}
/**
@private
Returns the hash or empty string
*/
function getHash(location) {
if (location.hash !== undefined) {
return location.hash.substr(0);
}
return '';
}
function getFullPath(location) {
return getPath(location) + getQuery(location) + getHash(location);
}
function getOrigin(location) {
let origin = location.origin;
// Older browsers, especially IE, don't have origin
if (!origin) {
origin = `${location.protocol}//${location.hostname}`;
if (location.port) {
origin += `:${location.port}`;
}
}
return origin;
}
/*
`documentMode` only exist in Internet Explorer, and it's tested because IE8 running in
IE7 compatibility mode claims to support `onhashchange` but actually does not.
`global` is an object that may have an `onhashchange` property.
@private
@function supportsHashChange
*/
function supportsHashChange(documentMode, global) {
return global && 'onhashchange' in global && (documentMode === undefined || documentMode > 7);
}
/*
`userAgent` is a user agent string. We use user agent testing here, because
the stock Android browser is known to have buggy versions of the History API,
in some Android versions.
@private
@function supportsHistory
*/
function supportsHistory(userAgent, history) {
// Boosted from Modernizr: https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
// The stock browser on Android 2.2 & 2.3, and 4.0.x returns positive on history support
// Unfortunately support is really buggy and there is no clean way to detect
// these bugs, so we fall back to a user agent sniff :(
// We only want Android 2 and 4.0, stock browser, and not Chrome which identifies
// itself as 'Mobile Safari' as well, nor Windows Phone.
if ((userAgent.indexOf('Android 2.') !== -1 || userAgent.indexOf('Android 4.0') !== -1) && userAgent.indexOf('Mobile Safari') !== -1 && userAgent.indexOf('Chrome') === -1 && userAgent.indexOf('Windows Phone') === -1) {
return false;
}
return !!(history && 'pushState' in history);
}
/**
Replaces the current location, making sure we explicitly include the origin
to prevent redirecting to a different origin.
@private
*/
function replacePath(location, path) {
location.replace(getOrigin(location) + path);
}
});
enifed('@ember/-internals/routing/lib/services/router', ['exports', '@ember/-internals/runtime', '@ember/debug', '@ember/object/computed', '@ember/service', '@ember/-internals/routing/lib/utils'], function (exports, _runtime, _debug, _computed, _service, _utils) {
'use strict';
let freezeRouteInfo;
if (false /* DEBUG */) {
freezeRouteInfo = transition => {
if (transition.from !== null && !Object.isFrozen(transition.from)) {
Object.freeze(transition.from);
}
if (transition.to !== null && !Object.isFrozen(transition.to)) {
Object.freeze(transition.to);
}
};
}
/**
The Router service is the public API that provides access to the router.
The immediate benefit of the Router service is that you can inject it into components,
giving them a friendly way to initiate transitions and ask questions about the current
global router state.
In this example, the Router service is injected into a component to initiate a transition
to a dedicated route:
```javascript
import Component from '@ember/component';
import { inject as service } from '@ember/service';
export default Component.extend({
router: service(),
actions: {
next() {
this.get('router').transitionTo('other.route');
}
}
});
```
Like any service, it can also be injected into helpers, routes, etc.
@public
@class RouterService
*/
class RouterService extends _service.default {
/**
Transition the application into another route. The route may
be either a single route or route path:
See [transitionTo](/api/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
@method transitionTo
@param {String} routeNameOrUrl the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {Transition} the transition object associated with this
attempted transition
@public
*/
transitionTo(...args) {
if ((0, _utils.resemblesURL)(args[0])) {
return this._router._doURLTransition('transitionTo', args[0]);
}
let { routeName, models, queryParams } = (0, _utils.extractRouteArgs)(args);
let transition = this._router._doTransition(routeName, models, queryParams, true);
transition['_keepDefaultQueryParamValues'] = true;
return transition;
}
/**
Transition into another route while replacing the current URL, if possible.
The route may be either a single route or route path:
See [replaceWith](/api/ember/release/classes/Route/methods/replaceWith?anchor=replaceWith) for more info.
Calling `replaceWith` from the Router service will cause default query parameter values to be included in the URL.
This behavior is different from calling `replaceWith` on a route.
See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
@method replaceWith
@param {String} routeNameOrUrl the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {Transition} the transition object associated with this
attempted transition
@public
*/
replaceWith() /* routeNameOrUrl, ...models, options */{
return this.transitionTo(...arguments).method('replace');
}
/**
Generate a URL based on the supplied route name.
@method urlFor
@param {String} routeName the name of the route
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {String} the string representing the generated URL
@public
*/
urlFor(routeName, ...args) {
return this._router.generate(routeName, ...args);
}
/**
Determines whether a route is active.
@method isActive
@param {String} routeName the name of the route
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {boolean} true if the provided routeName/models/queryParams are active
@public
*/
isActive(...args) {
let { routeName, models, queryParams } = (0, _utils.extractRouteArgs)(args);
let routerMicrolib = this._router._routerMicrolib;
if (!routerMicrolib.isActiveIntent(routeName, models)) {
return false;
}
let hasQueryParams = Object.keys(queryParams).length > 0;
if (hasQueryParams) {
this._router._prepareQueryParams(routeName, models, queryParams, true /* fromRouterService */);
return (0, _utils.shallowEqual)(queryParams, routerMicrolib.state.queryParams);
}
return true;
}
}
exports.default = RouterService;
RouterService.reopen({
/**
Name of the current route.
This property represents the logical name of the route,
which is comma separated.
For the following router:
```app/router.js
Router.map(function() {
this.route('about');
this.route('blog', function () {
this.route('post', { path: ':post_id' });
});
});
```
It will return:
* `index` when you visit `/`
* `about` when you visit `/about`
* `blog.index` when you visit `/blog`
* `blog.post` when you visit `/blog/some-post-id`
@property currentRouteName
@type String
@public
*/
currentRouteName: (0, _computed.readOnly)('_router.currentRouteName'),
/**
Current URL for the application.
This property represents the URL path for this route.
For the following router:
```app/router.js
Router.map(function() {
this.route('about');
this.route('blog', function () {
this.route('post', { path: ':post_id' });
});
});
```
It will return:
* `/` when you visit `/`
* `/about` when you visit `/about`
* `/blog` when you visit `/blog`
* `/blog/some-post-id` when you visit `/blog/some-post-id`
@property currentURL
@type String
@public
*/
currentURL: (0, _computed.readOnly)('_router.currentURL'),
/**
The `location` property determines the type of URL's that your
application will use.
The following location types are currently available:
* `auto`
* `hash`
* `history`
* `none`
@property location
@default 'hash'
@see {Location}
@public
*/
location: (0, _computed.readOnly)('_router.location'),
/**
The `rootURL` property represents the URL of the root of
the application, '/' by default.
This prefix is assumed on all routes defined on this app.
IF you change the `rootURL` in your environment configuration
like so:
```config/environment.js
'use strict';
module.exports = function(environment) {
let ENV = {
modulePrefix: 'router-service',
environment,
rootURL: '/my-root',
…
}
]
```
This property will return `/my-root`.
@property rootURL
@default '/'
@public
*/
rootURL: (0, _computed.readOnly)('_router.rootURL')
});
if (true /* EMBER_ROUTING_ROUTER_SERVICE */) {
const cleanURL = function (url, rootURL) {
if (rootURL === '/') {
return url;
}
return url.substr(rootURL.length, url.length);
};
RouterService.reopen(_runtime.Evented, {
init() {
this._super(...arguments);
this._router.on('routeWillChange', transition => {
if (false /* DEBUG */) {
freezeRouteInfo(transition);
}
this.trigger('routeWillChange', transition);
});
this._router.on('routeDidChange', transition => {
if (false /* DEBUG */) {
freezeRouteInfo(transition);
}
this.trigger('routeDidChange', transition);
});
},
/**
A RouteInfo that represents the current leaf route.
It is guaranteed to change whenever a route transition
happens (even when that transition only changes parameters
and doesn't change the active route)
@property currentRoute
@type RouteInfo
@category ember-routing-router-service
@public
*/
currentRoute: (0, _computed.readOnly)('_router.currentRoute'),
/**
Takes a string URL and returns a `RouteInfo` for the leafmost route represented
by the URL. Returns `null` if the URL is not recognized. This method expects to
receive the actual URL as seen by the browser including the app's `rootURL`.
@method recognize
@param {String} url
@category ember-routing-router-service
@public
*/
recognize(url) {
false && !(url.indexOf(this.rootURL) === 0) && (0, _debug.assert)(`You must pass a url that begins with the application's rootURL "${this.rootURL}"`, url.indexOf(this.rootURL) === 0);
let internalURL = cleanURL(url, this.rootURL);
return this._router._routerMicrolib.recognize(internalURL);
},
/**
Takes a string URL and returns a promise that resolves to a
`RouteInfoWithAttributes` for the leafmost route represented by the URL.
The promise rejects if the URL is not recognized or an unhandled exception
is encountered. This method expects to receive the actual URL as seen by
the browser including the app's `rootURL`.
@method recognizeAndLoad
@param {String} url
@category ember-routing-router-service
@public
*/
recognizeAndLoad(url) {
false && !(url.indexOf(this.rootURL) === 0) && (0, _debug.assert)(`You must pass a url that begins with the application's rootURL "${this.rootURL}"`, url.indexOf(this.rootURL) === 0);
let internalURL = cleanURL(url, this.rootURL);
return this._router._routerMicrolib.recognizeAndLoad(internalURL);
}
});
}
});
enifed('@ember/-internals/routing/lib/services/routing', ['exports', '@ember/-internals/metal', '@ember/object/computed', '@ember/polyfills', '@ember/service'], function (exports, _metal, _computed, _polyfills, _service) {
'use strict';
/**
The Routing service is used by LinkComponent, and provides facilities for
the component/view layer to interact with the router.
This is a private service for internal usage only. For public usage,
refer to the `Router` service.
@private
@class RoutingService
*/
/**
@module ember
*/
class RoutingService extends _service.default {
hasRoute(routeName) {
return (0, _metal.get)(this, 'router').hasRoute(routeName);
}
transitionTo(routeName, models, queryParams, shouldReplace) {
let router = (0, _metal.get)(this, 'router');
let transition = router._doTransition(routeName, models, queryParams);
if (shouldReplace) {
transition.method('replace');
}
return transition;
}
normalizeQueryParams(routeName, models, queryParams) {
(0, _metal.get)(this, 'router')._prepareQueryParams(routeName, models, queryParams);
}
generateURL(routeName, models, queryParams) {
let router = (0, _metal.get)(this, 'router');
// return early when the router microlib is not present, which is the case for {{link-to}} in integration tests
if (!router._routerMicrolib) {
return;
}
let visibleQueryParams = {};
if (queryParams) {
(0, _polyfills.assign)(visibleQueryParams, queryParams);
this.normalizeQueryParams(routeName, models, visibleQueryParams);
}
return router.generate(routeName, ...models, {
queryParams: visibleQueryParams
});
}
isActiveForRoute(contexts, queryParams, routeName, routerState, isCurrentWhenSpecified) {
let router = (0, _metal.get)(this, 'router');
let handlers = router._routerMicrolib.recognizer.handlersFor(routeName);
let leafName = handlers[handlers.length - 1].handler;
let maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
// NOTE: any ugliness in the calculation of activeness is largely
// due to the fact that we support automatic normalizing of
// `resource` -> `resource.index`, even though there might be
// dynamic segments / query params defined on `resource.index`
// which complicates (and makes somewhat ambiguous) the calculation
// of activeness for links that link to `resource` instead of
// directly to `resource.index`.
// if we don't have enough contexts revert back to full route name
// this is because the leaf route will use one of the contexts
if (contexts.length > maximumContexts) {
routeName = leafName;
}
return routerState.isActiveIntent(routeName, contexts, queryParams, !isCurrentWhenSpecified);
}
}
exports.default = RoutingService;
RoutingService.reopen({
targetState: (0, _computed.readOnly)('router.targetState'),
currentState: (0, _computed.readOnly)('router.currentState'),
currentRouteName: (0, _computed.readOnly)('router.currentRouteName'),
currentPath: (0, _computed.readOnly)('router.currentPath')
});
function numberOfContextsAcceptedByHandler(handlerName, handlerInfos) {
let req = 0;
for (let i = 0; i < handlerInfos.length; i++) {
req += handlerInfos[i].names.length;
if (handlerInfos[i].handler === handlerName) {
break;
}
}
return req;
}
});
enifed("@ember/-internals/routing/lib/system/cache", ["exports"], function (exports) {
"use strict";
/**
A two-tiered cache with support for fallback values when doing lookups.
Uses "buckets" and then "keys" to cache values.
@private
@class BucketCache
*/
class BucketCache {
constructor() {
this.cache = new Map();
}
has(bucketKey) {
return this.cache.has(bucketKey);
}
stash(bucketKey, key, value) {
let bucket = this.cache.get(bucketKey);
if (bucket === undefined) {
bucket = new Map();
this.cache.set(bucketKey, bucket);
}
bucket.set(key, value);
}
lookup(bucketKey, prop, defaultValue) {
if (!this.has(bucketKey)) {
return defaultValue;
}
let bucket = this.cache.get(bucketKey);
if (bucket.has(prop)) {
return bucket.get(prop);
} else {
return defaultValue;
}
}
}
exports.default = BucketCache;
});
enifed("@ember/-internals/routing/lib/system/controller_for", ["exports"], function (exports) {
"use strict";
exports.default = controllerFor;
/**
@module ember
*/
/**
Finds a controller instance.
@for Ember
@method controllerFor
@private
*/
function controllerFor(container, controllerName, lookupOptions) {
return container.lookup(`controller:${controllerName}`, lookupOptions);
}
});
enifed('@ember/-internals/routing/lib/system/dsl', ['exports', '@ember/debug', '@ember/polyfills'], function (exports, _debug, _polyfills) {
'use strict';
let uuid = 0;
class DSL {
constructor(name = null, options) {
this.explicitIndex = false;
this.parent = name;
this.enableLoadingSubstates = !!(options && options.enableLoadingSubstates);
this.matches = [];
this.options = options;
}
route(name, options = {}, callback) {
let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
if (arguments.length === 2 && typeof options === 'function') {
callback = options;
options = {};
}
false && !(() => {
if (options.overrideNameAssertion === true) {
return true;
}
return ['basic', 'application'].indexOf(name) === -1;
})() && (0, _debug.assert)(`'${name}' cannot be used as a route name.`, (() => {
if (options.overrideNameAssertion === true) {
return true;
}return ['basic', 'application'].indexOf(name) === -1;
})());
false && !(name.indexOf(':') === -1) && (0, _debug.assert)(`'${name}' is not a valid route name. It cannot contain a ':'. You may want to use the 'path' option instead.`, name.indexOf(':') === -1);
if (this.enableLoadingSubstates) {
createRoute(this, `${name}_loading`, {
resetNamespace: options.resetNamespace
});
createRoute(this, `${name}_error`, {
resetNamespace: options.resetNamespace,
path: dummyErrorRoute
});
}
if (callback) {
let fullName = getFullName(this, name, options.resetNamespace);
let dsl = new DSL(fullName, this.options);
createRoute(dsl, 'loading');
createRoute(dsl, 'error', { path: dummyErrorRoute });
callback.call(dsl);
createRoute(this, name, options, dsl.generate());
} else {
createRoute(this, name, options);
}
}
push(url, name, callback, serialize) {
let parts = name.split('.');
if (this.options.engineInfo) {
let localFullName = name.slice(this.options.engineInfo.fullName.length + 1);
let routeInfo = (0, _polyfills.assign)({ localFullName }, this.options.engineInfo);
if (serialize) {
routeInfo.serializeMethod = serialize;
}
this.options.addRouteForEngine(name, routeInfo);
} else if (serialize) {
throw new Error(`Defining a route serializer on route '${name}' outside an Engine is not allowed.`);
}
if (url === '' || url === '/' || parts[parts.length - 1] === 'index') {
this.explicitIndex = true;
}
this.matches.push(url, name, callback);
}
generate() {
let dslMatches = this.matches;
if (!this.explicitIndex) {
this.route('index', { path: '/' });
}
return match => {
for (let i = 0; i < dslMatches.length; i += 3) {
match(dslMatches[i]).to(dslMatches[i + 1], dslMatches[i + 2]);
}
};
}
mount(_name, options = {}) {
let engineRouteMap = this.options.resolveRouteMap(_name);
let name = _name;
if (options.as) {
name = options.as;
}
let fullName = getFullName(this, name, options.resetNamespace);
let engineInfo = {
name: _name,
instanceId: uuid++,
mountPoint: fullName,
fullName
};
let path = options.path;
if (typeof path !== 'string') {
path = `/${name}`;
}
let callback;
let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
if (engineRouteMap) {
let shouldResetEngineInfo = false;
let oldEngineInfo = this.options.engineInfo;
if (oldEngineInfo) {
shouldResetEngineInfo = true;
this.options.engineInfo = engineInfo;
}
let optionsForChild = (0, _polyfills.assign)({ engineInfo }, this.options);
let childDSL = new DSL(fullName, optionsForChild);
createRoute(childDSL, 'loading');
createRoute(childDSL, 'error', { path: dummyErrorRoute });
engineRouteMap.class.call(childDSL);
callback = childDSL.generate();
if (shouldResetEngineInfo) {
this.options.engineInfo = oldEngineInfo;
}
}
let localFullName = 'application';
let routeInfo = (0, _polyfills.assign)({ localFullName }, engineInfo);
if (this.enableLoadingSubstates) {
// These values are important to register the loading routes under their
// proper names for the Router and within the Engine's registry.
let substateName = `${name}_loading`;
let localFullName = `application_loading`;
let routeInfo = (0, _polyfills.assign)({ localFullName }, engineInfo);
createRoute(this, substateName, {
resetNamespace: options.resetNamespace
});
this.options.addRouteForEngine(substateName, routeInfo);
substateName = `${name}_error`;
localFullName = `application_error`;
routeInfo = (0, _polyfills.assign)({ localFullName }, engineInfo);
createRoute(this, substateName, {
resetNamespace: options.resetNamespace,
path: dummyErrorRoute
});
this.options.addRouteForEngine(substateName, routeInfo);
}
this.options.addRouteForEngine(fullName, routeInfo);
this.push(path, fullName, callback);
}
}
exports.default = DSL;
function canNest(dsl) {
return dsl.parent !== 'application';
}
function getFullName(dsl, name, resetNamespace) {
if (canNest(dsl) && resetNamespace !== true) {
return `${dsl.parent}.${name}`;
} else {
return name;
}
}
function createRoute(dsl, name, options = {}, callback) {
let fullName = getFullName(dsl, name, options.resetNamespace);
if (typeof options.path !== 'string') {
options.path = `/${name}`;
}
dsl.push(options.path, fullName, callback, options.serialize);
}
});
enifed("@ember/-internals/routing/lib/system/engines", [], function () {
"use strict";
});
enifed('@ember/-internals/routing/lib/system/generate_controller', ['exports', '@ember/-internals/metal', '@ember/debug'], function (exports, _metal, _debug) {
'use strict';
exports.generateControllerFactory = generateControllerFactory;
exports.default = generateController;
/**
@module ember
*/
/**
Generates a controller factory
@for Ember
@method generateControllerFactory
@private
*/
function generateControllerFactory(owner, controllerName) {
let Factory = owner.factoryFor('controller:basic').class;
Factory = Factory.extend({
toString() {
return `(generated ${controllerName} controller)`;
}
});
let fullName = `controller:${controllerName}`;
owner.register(fullName, Factory);
return Factory;
}
/**
Generates and instantiates a controller extending from `controller:basic`
if present, or `Controller` if not.
@for Ember
@method generateController
@private
@since 1.3.0
*/
function generateController(owner, controllerName) {
generateControllerFactory(owner, controllerName);
let fullName = `controller:${controllerName}`;
let instance = owner.lookup(fullName);
if (false /* DEBUG */) {
if ((0, _metal.get)(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
(0, _debug.info)(`generated -> ${fullName}`, { fullName });
}
}
return instance;
}
});
enifed("@ember/-internals/routing/lib/system/query_params", ["exports"], function (exports) {
"use strict";
class QueryParams {
constructor(values = null) {
this.isQueryParams = true;
this.values = values;
}
}
exports.default = QueryParams;
});
enifed("@ember/-internals/routing/lib/system/route-info", [], function () {
"use strict";
/**
A `RouteInfoWithAttributes` is an object that contains
metadata, including the resolved value from the routes
`model` hook. Like `RouteInfo`, a `RouteInfoWithAttributes`
represents a specific route within a Transition.
It is read-only and internally immutable. It is also not
observable, because a Transition instance is never
changed after creation.
@class RouteInfoWithAttributes
@category ember-routing-router-service
@public
*/
/**
The dot-separated, fully-qualified name of the
route, like "people.index".
@property {String} name
@category ember-routing-router-service
@public
*/
/**
The final segment of the fully-qualified name of
the route, like "index"
@property {String} localName
@category ember-routing-router-service
@public
*/
/**
The values of the route's parameters. These are the
same params that are received as arguments to the
route's model hook. Contains only the parameters
valid for this route, if any (params for parent or
child routes are not merged).
@property {Object} params
@category ember-routing-router-service
@public
*/
/**
The ordered list of the names of the params
required for this route. It will contain the same
strings as Object.keys(params), but here the order
is significant. This allows users to correctly pass
params into routes programmatically.
@property {Array} paramNames
@category ember-routing-router-service
@public
*/
/**
The values of any queryParams on this route.
@property {Object} queryParams
@category ember-routing-router-service
@public
*/
/**
This is the resolved return value from the
route's model hook.
@property {Object|Array|String} attributes
@category ember-routing-router-service
@public
*/
/**
A reference to the parent route's RouteInfo.
This can be used to traverse upward to the topmost
`RouteInfo`.
@property {RouteInfo|null} parent
@category ember-routing-router-service
@public
*/
/**
A reference to the child route's RouteInfo.
This can be used to traverse downward to the
leafmost `RouteInfo`.
@property {RouteInfo|null} child
@category ember-routing-router-service
@public
Allows you to traverse through the linked list
of `RouteInfo`s from the topmost to leafmost.
Returns the first `RouteInfo` in the linked list
for which the callback returns true.
This method is similar to the `find()` method
defined in ECMAScript 2015.
The callback method you provide should have the
following signature (all parameters are optional):
```javascript
function(item, index, array);
```
- `item` is the current item in the iteration.
- `index` is the current index in the iteration.
- `array` is the array itself.
It should return the `true` to include the item in
the results, `false` otherwise.
Note that in addition to a callback, you can also
pass an optional target object that will be set as
`this` on the context.
@method find
@param {Function} callback the callback to execute
@param {Object} [target*] optional target to use
@returns {Object} Found item or undefined
@category ember-routing-router-service
@public
*/
/**
A RouteInfo is an object that contains metadata
about a specific route within a Transition. It is
read-only and internally immutable. It is also not
observable, because a Transition instance is never
changed after creation.
@class RouteInfo
@category ember-routing-router-service
@public
*/
/**
The dot-separated, fully-qualified name of the
route, like "people.index".
@property {String} name
@category ember-routing-router-service
@public
*/
/**
The final segment of the fully-qualified name of
the route, like "index"
@property {String} localName
@category ember-routing-router-service
@public
*/
/**
The values of the route's parametes. These are the
same params that are received as arguments to the
route's model hook. Contains only the parameters
valid for this route, if any (params for parent or
child routes are not merged).
@property {Object} params
@category ember-routing-router-service
@public
*/
/**
The ordered list of the names of the params
required for this route. It will contain the same
strings as Object.keys(params), but here the order
is significant. This allows users to correctly pass
params into routes programmatically.
@property {Array} paramNames
@category ember-routing-router-service
@public
*/
/**
The values of any queryParams on this route.
@property {Object} queryParams
@category ember-routing-router-service
@public
*/
/**
A reference to the parent route's RouteInfo.
This can be used to traverse upward to the topmost
`RouteInfo`.
@property {RouteInfo|null} parent
@category ember-routing-router-service
@public
*/
/**
A reference to the child route's RouteInfo.
This can be used to traverse downward to the
leafmost `RouteInfo`.
@property {RouteInfo|null} child
@category ember-routing-router-service
@public
Allows you to traverse through the linked list
of `RouteInfo`s from the topmost to leafmost.
Returns the first `RouteInfo` in the linked list
for which the callback returns true.
This method is similar to the `find()` method
defined in ECMAScript 2015.
The callback method you provide should have the
following signature (all parameters are optional):
```javascript
function(item, index, array);
```
- `item` is the current item in the iteration.
- `index` is the current index in the iteration.
- `array` is the array itself.
It should return the `true` to include the item in
the results, `false` otherwise.
Note that in addition to a callback, you can also
pass an optional target object that will be set as
`this` on the context.
@method find
@param {Function} callback the callback to execute
@param {Object} [target*] optional target to use
@returns {Object} Found item or undefined
@category ember-routing-router-service
@public
*/
});
enifed('@ember/-internals/routing/lib/system/route', ['exports', '@ember/-internals/metal', '@ember/-internals/owner', '@ember/-internals/runtime', '@ember/debug', '@ember/deprecated-features', '@ember/polyfills', '@ember/runloop', '@ember/string', 'router_js', '@ember/-internals/routing/lib/utils', '@ember/-internals/routing/lib/system/generate_controller'], function (exports, _metal, _owner, _runtime, _debug, _deprecatedFeatures, _polyfills, _runloop, _string, _router_js, _utils, _generate_controller) {
'use strict';
exports.ROUTER_EVENT_DEPRECATIONS = undefined;
exports.defaultSerialize = defaultSerialize;
exports.hasDefaultSerialize = hasDefaultSerialize;
function defaultSerialize(model, params) {
if (params.length < 1 || !model) {
return;
}
let object = {};
if (params.length === 1) {
let [name] = params;
if (name in model) {
object[name] = (0, _metal.get)(model, name);
} else if (/_id$/.test(name)) {
object[name] = (0, _metal.get)(model, 'id');
}
} else {
object = (0, _metal.getProperties)(model, params);
}
return object;
}
function hasDefaultSerialize(route) {
return route.serialize === defaultSerialize;
}
/**
@module @ember/routing
*/
/**
The `Route` class is used to define individual routes. Refer to
the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
@class Route
@extends EmberObject
@uses ActionHandler
@uses Evented
@since 1.0.0
@public
*/
class Route extends _runtime.Object {
constructor() {
super(...arguments);
this.context = {};
}
/**
The name of the route, dot-delimited.
For example, a route found at `app/routes/posts/post.js` will have
a `routeName` of `posts.post`.
@property routeName
@for Route
@type String
@since 1.0.0
@public
*/
/**
The name of the route, dot-delimited, including the engine prefix
if applicable.
For example, a route found at `addon/routes/posts/post.js` within an
engine named `admin` will have a `fullRouteName` of `admin.posts.post`.
@property fullRouteName
@for Route
@type String
@since 2.10.0
@public
*/
/**
Sets the name for this route, including a fully resolved name for routes
inside engines.
@private
@method _setRouteName
@param {String} name
*/
_setRouteName(name) {
this.routeName = name;
this.fullRouteName = getEngineRouteName((0, _owner.getOwner)(this), name);
}
/**
@private
@method _stashNames
*/
_stashNames(routeInfo, dynamicParent) {
if (this._names) {
return;
}
let names = this._names = routeInfo['_names'];
if (!names.length) {
routeInfo = dynamicParent;
names = routeInfo && routeInfo['_names'] || [];
}
let qps = (0, _metal.get)(this, '_qp.qps');
let namePaths = new Array(names.length);
for (let a = 0; a < names.length; ++a) {
namePaths[a] = `${routeInfo.name}.${names[a]}`;
}
for (let i = 0; i < qps.length; ++i) {
let qp = qps[i];
if (qp.scope === 'model') {
qp.parts = namePaths;
}
}
}
/**
@private
@property _activeQPChanged
*/
_activeQPChanged(qp, value) {
this._router._activeQPChanged(qp.scopedPropertyName, value);
}
/**
@private
@method _updatingQPChanged
*/
_updatingQPChanged(qp) {
this._router._updatingQPChanged(qp.urlKey);
}
/**
Returns a hash containing the parameters of an ancestor route.
Example
```app/router.js
// ...
Router.map(function() {
this.route('member', { path: ':name' }, function() {
this.route('interest', { path: ':interest' });
});
});
```
```app/routes/member.js
import Route from '@ember/routing/route';
export default Route.extend({
queryParams: {
memberQp: { refreshModel: true }
}
});
```
```app/routes/member/interest.js
import Route from '@ember/routing/route';
export default Route.extend({
queryParams: {
interestQp: { refreshModel: true }
},
model() {
return this.paramsFor('member');
}
});
```
If we visit `/turing/maths?memberQp=member&interestQp=interest` the model for
the `member.interest` route is a hash with:
* `name`: `turing`
* `memberQp`: `member`
@method paramsFor
@param {String} name
@return {Object} hash containing the parameters of the route `name`
@since 1.4.0
@public
*/
paramsFor(name) {
let route = (0, _owner.getOwner)(this).lookup(`route:${name}`);
if (!route) {
return {};
}
let transition = this._router._routerMicrolib.activeTransition;
let state = transition ? transition[_router_js.STATE_SYMBOL] : this._router._routerMicrolib.state;
let fullName = route.fullRouteName;
let params = (0, _polyfills.assign)({}, state.params[fullName]);
let queryParams = getQueryParamsFor(route, state);
return Object.keys(queryParams).reduce((params, key) => {
false && !!params[key] && (0, _debug.assert)(`The route '${this.routeName}' has both a dynamic segment and query param with name '${key}'. Please rename one to avoid collisions.`, !params[key]);
params[key] = queryParams[key];
return params;
}, params);
}
/**
Serializes the query parameter key
@method serializeQueryParamKey
@param {String} controllerPropertyName
@private
*/
serializeQueryParamKey(controllerPropertyName) {
return controllerPropertyName;
}
/**
Serializes value of the query parameter based on defaultValueType
@method serializeQueryParam
@param {Object} value
@param {String} urlKey
@param {String} defaultValueType
@private
*/
serializeQueryParam(value, _urlKey, defaultValueType) {
// urlKey isn't used here, but anyone overriding
// can use it to provide serialization specific
// to a certain query param.
return this._router._serializeQueryParam(value, defaultValueType);
}
/**
Deserializes value of the query parameter based on defaultValueType
@method deserializeQueryParam
@param {Object} value
@param {String} urlKey
@param {String} defaultValueType
@private
*/
deserializeQueryParam(value, _urlKey, defaultValueType) {
// urlKey isn't used here, but anyone overriding
// can use it to provide deserialization specific
// to a certain query param.
return this._router._deserializeQueryParam(value, defaultValueType);
}
/**
@private
@property _optionsForQueryParam
*/
_optionsForQueryParam(qp) {
return (0, _metal.get)(this, `queryParams.${qp.urlKey}`) || (0, _metal.get)(this, `queryParams.${qp.prop}`) || {};
}
/**
A hook you can use to reset controller values either when the model
changes or the route is exiting.
```app/routes/articles.js
import Route from '@ember/routing/route';
export default Route.extend({
resetController(controller, isExiting, transition) {
if (isExiting && transition.targetName !== 'error') {
controller.set('page', 1);
}
}
});
```
@method resetController
@param {Controller} controller instance
@param {Boolean} isExiting
@param {Object} transition
@since 1.7.0
@public
*/
resetController(_controller, _isExiting, _transition) {
return this;
}
/**
@private
@method exit
*/
exit() {
this.deactivate();
this.trigger('deactivate');
this.teardownViews();
}
/**
@private
@method _internalReset
@since 3.6.0
*/
_internalReset(isExiting, transition) {
let controller = this.controller;
controller._qpDelegate = (0, _metal.get)(this, '_qp.states.inactive');
this.resetController(controller, isExiting, transition);
}
/**
@private
@method enter
*/
enter() {
this.connections = [];
this.activate();
this.trigger('activate');
}
/**
The `willTransition` action is fired at the beginning of any
attempted transition with a `Transition` object as the sole
argument. This action can be used for aborting, redirecting,
or decorating the transition from the currently active routes.
A good example is preventing navigation when a form is
half-filled out:
```app/routes/contact-form.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
willTransition(transition) {
if (this.controller.get('userHasEnteredData')) {
this.controller.displayNavigationConfirm();
transition.abort();
}
}
}
});
```
You can also redirect elsewhere by calling
`this.transitionTo('elsewhere')` from within `willTransition`.
Note that `willTransition` will not be fired for the
redirecting `transitionTo`, since `willTransition` doesn't
fire when there is already a transition underway. If you want
subsequent `willTransition` actions to fire for the redirecting
transition, you must first explicitly call
`transition.abort()`.
To allow the `willTransition` event to continue bubbling to the parent
route, use `return true;`. When the `willTransition` method has a
return value of `true` then the parent route's `willTransition` method
will be fired, enabling "bubbling" behavior for the event.
@event willTransition
@param {Transition} transition
@since 1.0.0
@public
*/
/**
The `didTransition` action is fired after a transition has
successfully been completed. This occurs after the normal model
hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
have resolved. The `didTransition` action has no arguments,
however, it can be useful for tracking page views or resetting
state on the controller.
```app/routes/login.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
didTransition() {
this.controller.get('errors.base').clear();
return true; // Bubble the didTransition event
}
}
});
```
@event didTransition
@since 1.2.0
@public
*/
/**
The `loading` action is fired on the route when a route's `model`
hook returns a promise that is not already resolved. The current
`Transition` object is the first parameter and the route that
triggered the loading event is the second parameter.
```app/routes/application.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
loading(transition, route) {
let controller = this.controllerFor('foo');
controller.set('currentlyLoading', true);
transition.finally(function() {
controller.set('currentlyLoading', false);
});
}
}
});
```
@event loading
@param {Transition} transition
@param {Route} route The route that triggered the loading event
@since 1.2.0
@public
*/
/**
When attempting to transition into a route, any of the hooks
may return a promise that rejects, at which point an `error`
action will be fired on the partially-entered routes, allowing
for per-route error handling logic, or shared error handling
logic defined on a parent route.
Here is an example of an error handler that will be invoked
for rejected promises from the various hooks on the route,
as well as any unhandled errors from child routes:
```app/routes/admin.js
import { reject } from 'rsvp';
import Route from '@ember/routing/route';
export default Route.extend({
beforeModel() {
return reject('bad things!');
},
actions: {
error(error, transition) {
// Assuming we got here due to the error in `beforeModel`,
// we can expect that error === "bad things!",
// but a promise model rejecting would also
// call this hook, as would any errors encountered
// in `afterModel`.
// The `error` hook is also provided the failed
// `transition`, which can be stored and later
// `.retry()`d if desired.
this.transitionTo('login');
}
}
});
```
`error` actions that bubble up all the way to `ApplicationRoute`
will fire a default error handler that logs the error. You can
specify your own global default error handler by overriding the
`error` handler on `ApplicationRoute`:
```app/routes/application.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
error(error, transition) {
this.controllerFor('banner').displayError(error.message);
}
}
});
```
@event error
@param {Error} error
@param {Transition} transition
@since 1.0.0
@public
*/
/**
This event is triggered when the router enters the route. It is
not executed when the model for the route changes.
```app/routes/application.js
import { on } from '@ember/object/evented';
import Route from '@ember/routing/route';
export default Route.extend({
collectAnalytics: on('activate', function(){
collectAnalytics();
})
});
```
@event activate
@since 1.9.0
@public
*/
/**
This event is triggered when the router completely exits this
route. It is not executed when the model for the route changes.
```app/routes/index.js
import { on } from '@ember/object/evented';
import Route from '@ember/routing/route';
export default Route.extend({
trackPageLeaveAnalytics: on('deactivate', function(){
trackPageLeaveAnalytics();
})
});
```
@event deactivate
@since 1.9.0
@public
*/
/**
This hook is executed when the router completely exits this route. It is
not executed when the model for the route changes.
@method deactivate
@since 1.0.0
@public
*/
deactivate() {}
/**
This hook is executed when the router enters the route. It is not executed
when the model for the route changes.
@method activate
@since 1.0.0
@public
*/
activate() {}
/**
Transition the application into another route. The route may
be either a single route or route path:
```javascript
this.transitionTo('blogPosts');
this.transitionTo('blogPosts.recentEntries');
```
Optionally supply a model for the route in question. The model
will be serialized into the URL using the `serialize` hook of
the route:
```javascript
this.transitionTo('blogPost', aPost);
```
If a literal is passed (such as a number or a string), it will
be treated as an identifier instead. In this case, the `model`
hook of the route will be triggered:
```javascript
this.transitionTo('blogPost', 1);
```
Multiple models will be applied last to first recursively up the
route tree.
```app/routes.js
// ...
Router.map(function() {
this.route('blogPost', { path:':blogPostId' }, function() {
this.route('blogComment', { path: ':blogCommentId' });
});
});
export default Router;
```
```javascript
this.transitionTo('blogComment', aPost, aComment);
this.transitionTo('blogComment', 1, 13);
```
It is also possible to pass a URL (a string that starts with a
`/`).
```javascript
this.transitionTo('/');
this.transitionTo('/blog/post/1/comment/13');
this.transitionTo('/blog/posts?sort=title');
```
An options hash with a `queryParams` property may be provided as
the final argument to add query parameters to the destination URL.
```javascript
this.transitionTo('blogPost', 1, {
queryParams: { showComments: 'true' }
});
// if you just want to transition the query parameters without changing the route
this.transitionTo({ queryParams: { sort: 'date' } });
```
See also [replaceWith](#method_replaceWith).
Simple Transition Example
```app/routes.js
// ...
Router.map(function() {
this.route('index');
this.route('secret');
this.route('fourOhFour', { path: '*:' });
});
export default Router;
```
```app/routes/index.js
import Route from '@ember/routing/route';
export Route.extend({
actions: {
moveToSecret(context) {
if (authorized()) {
this.transitionTo('secret', context);
} else {
this.transitionTo('fourOhFour');
}
}
}
});
```
Transition to a nested route
```app/router.js
// ...
Router.map(function() {
this.route('articles', { path: '/articles' }, function() {
this.route('new');
});
});
export default Router;
```
```app/routes/index.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
transitionToNewArticle() {
this.transitionTo('articles.new');
}
}
});
```
Multiple Models Example
```app/router.js
// ...
Router.map(function() {
this.route('index');
this.route('breakfast', { path: ':breakfastId' }, function() {
this.route('cereal', { path: ':cerealId' });
});
});
export default Router;
```
```app/routes/index.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
moveToChocolateCereal() {
let cereal = { cerealId: 'ChocolateYumminess' };
let breakfast = { breakfastId: 'CerealAndMilk' };
this.transitionTo('breakfast.cereal', breakfast, cereal);
}
}
});
```
Nested Route with Query String Example
```app/routes.js
// ...
Router.map(function() {
this.route('fruits', function() {
this.route('apples');
});
});
export default Router;
```
```app/routes/index.js
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
transitionToApples() {
this.transitionTo('fruits.apples', { queryParams: { color: 'red' } });
}
}
});
```
@method transitionTo
@param {String} name the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {Transition} the transition object associated with this
attempted transition
@since 1.0.0
@public
*/
transitionTo(...args) {
// eslint-disable-line no-unused-vars
return this._router.transitionTo(...(0, _utils.prefixRouteNameArg)(this, args));
}
/**
Perform a synchronous transition into another route without attempting
to resolve promises, update the URL, or abort any currently active
asynchronous transitions (i.e. regular transitions caused by
`transitionTo` or URL changes).
This method is handy for performing intermediate transitions on the
way to a final destination route, and is called internally by the
default implementations of the `error` and `loading` handlers.
@method intermediateTransitionTo
@param {String} name the name of the route
@param {...Object} models the model(s) to be used while transitioning
to the route.
@since 1.2.0
@public
*/
intermediateTransitionTo(...args) {
let [name, ...preparedArgs] = (0, _utils.prefixRouteNameArg)(this, args);
this._router.intermediateTransitionTo(name, ...preparedArgs);
}
/**
Refresh the model on this route and any child routes, firing the
`beforeModel`, `model`, and `afterModel` hooks in a similar fashion
to how routes are entered when transitioning in from other route.
The current route params (e.g. `article_id`) will be passed in
to the respective model hooks, and if a different model is returned,
`setupController` and associated route hooks will re-fire as well.
An example usage of this method is re-querying the server for the
latest information using the same parameters as when the route
was first entered.
Note that this will cause `model` hooks to fire even on routes
that were provided a model object when the route was initially
entered.
@method refresh
@return {Transition} the transition object associated with this
attempted transition
@since 1.4.0
@public
*/
refresh() {
return this._router._routerMicrolib.refresh(this);
}
/**
Transition into another route while replacing the current URL, if possible.
This will replace the current history entry instead of adding a new one.
Beside that, it is identical to `transitionTo` in all other respects. See
'transitionTo' for additional information regarding multiple models.
Example
```app/router.js
// ...
Router.map(function() {
this.route('index');
this.route('secret');
});
export default Router;
```
```app/routes/secret.js
import Route from '@ember/routing/route';
export default Route.extend({
afterModel() {
if (!authorized()){
this.replaceWith('index');
}
}
});
```
@method replaceWith
@param {String} name the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used while
transitioning to the route.
@param {Object} [options] optional hash with a queryParams property
containing a mapping of query parameters
@return {Transition} the transition object associated with this
attempted transition
@since 1.0.0
@public
*/
replaceWith(...args) {
return this._router.replaceWith(...(0, _utils.prefixRouteNameArg)(this, args));
}
/**
This hook is the entry point for router.js
@private
@method setup
*/
setup(context, transition) {
let controller;
let controllerName = this.controllerName || this.routeName;
let definedController = this.controllerFor(controllerName, true);
if (definedController) {
controller = definedController;
} else {
controller = this.generateController(controllerName);
}
// Assign the route's controller so that it can more easily be
// referenced in action handlers. Side effects. Side effects everywhere.
if (!this.controller) {
let qp = (0, _metal.get)(this, '_qp');
let propNames = qp !== undefined ? (0, _metal.get)(qp, 'propertyNames') : [];
addQueryParamsObservers(controller, propNames);
this.controller = controller;
}
let queryParams = (0, _metal.get)(this, '_qp');
let states = queryParams.states;
controller._qpDelegate = states.allowOverrides;
if (transition) {
// Update the model dep values used to calculate cache keys.
(0, _utils.stashParamNames)(this._router, transition[_router_js.STATE_SYMBOL].routeInfos);
let cache = this._bucketCache;
let params = transition[_router_js.PARAMS_SYMBOL];
let allParams = queryParams.propertyNames;
allParams.forEach(prop => {
let aQp = queryParams.map[prop];
aQp.values = params;
let cacheKey = (0, _utils.calculateCacheKey)(aQp.route.fullRouteName, aQp.parts, aQp.values);
let value = cache.lookup(cacheKey, prop, aQp.undecoratedDefaultValue);
(0, _metal.set)(controller, prop, value);
});
let qpValues = getQueryParamsFor(this, transition[_router_js.STATE_SYMBOL]);
(0, _metal.setProperties)(controller, qpValues);
}
this.setupController(controller, context, transition);
if (this._environment.options.shouldRender) {
this.renderTemplate(controller, context);
}
}
/*
Called when a query parameter for this route changes, regardless of whether the route
is currently part of the active route hierarchy. This will update the query parameter's
value in the cache so if this route becomes active, the cache value has been updated.
*/
_qpChanged(prop, value, qp) {
if (!qp) {
return;
}
// Update model-dep cache
let cache = this._bucketCache;
let cacheKey = (0, _utils.calculateCacheKey)(qp.route.fullRouteName, qp.parts, qp.values);
cache.stash(cacheKey, prop, value);
}
/**
This hook is the first of the route entry validation hooks
called when an attempt is made to transition into a route
or one of its children. It is called before `model` and
`afterModel`, and is appropriate for cases when:
1) A decision can be made to redirect elsewhere without
needing to resolve the model first.
2) Any async operations need to occur first before the
model is attempted to be resolved.
This hook is provided the current `transition` attempt
as a parameter, which can be used to `.abort()` the transition,
save it for a later `.retry()`, or retrieve values set
on it from a previous hook. You can also just call
`this.transitionTo` to another route to implicitly
abort the `transition`.
You can return a promise from this hook to pause the
transition until the promise resolves (or rejects). This could
be useful, for instance, for retrieving async code from
the server that is required to enter a route.
@method beforeModel
@param {Transition} transition
@return {any | Promise
{{outlet "anOutletName"}}
```
```handlebars