Class TextArea public
import TextArea from '@ember/component/text-area';
The internal class used to create textarea element when the {{textarea}}
helper is used.
See Ember.Templates.helpers.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.
Methods
$ (selector) : JQuery public
Inherited from Component packages/ember-glimmer/lib/component.ts:874
- selector
- String
a jQuery-compatible selector string
- returns
- JQuery
the jQuery object for the DOM node
Returns a jQuery object for this component's element. If you pass in a selector
string, this method will return a jQuery object, using the current element
as its buffer.
For example, calling component.$('li')
will return a jQuery object containing
all of the li
elements inside the DOM element of this component.
addObserver (key, target, method) : Ember.Observable public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:331
- key
- String
The key to observe
- target
- Object
The target object to invoke
- method
- String|Function
The method to invoke
- returns
- Ember.Observable
Adds an observer on a property.
This is the core method used to register an observer for a property.
Once you call this method, any time the key's value is set, your observer will be notified. Note that the observers are triggered any time the value is set, regardless of whether it has actually changed. Your observer should be prepared to handle that.
Observer Methods
Observer methods have the following signature:
import Component from '@ember/component';
export default Component.extend({
init() {
this._super(...arguments);
this.addObserver('foo', this, 'fooDidChange');
},
fooDidChange(sender, key, value, rev) {
// your code
}
});
The sender
is the object that changed. The key
is the property that
changes. The value
property is currently reserved and unused. The rev
is the last property revision of the object when it changed, which you can
use to detect if the key value has really changed or not.
Usually you will not need the value or revision parameters at the end. In this case, it is common to write observer methods that take only a sender and key value as parameters or, if you aren't interested in any of these values, to write an observer that has no parameters at all.
cacheFor (keyName) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:489
- keyName
- String
- returns
- Object
The cached value of the computed property, if any
Returns the cached value of a computed property, if it exists. This allows you to inspect the value of a computed property without accidentally invoking it if it is intended to be generated lazily.
decrementProperty (keyName, decrement) : Number public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:452
- keyName
- String
The name of the property to decrement
- decrement
- Number
The amount to decrement by. Defaults to 1
- returns
- Number
The new property value
Set the value of a property to the current value minus some amount.
player.decrementProperty('lives');
orc.decrementProperty('health', 5);
destroy : EmberObject public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:445
- returns
- EmberObject
receiver
Destroys an object by setting the isDestroyed
flag and removing its
metadata, which effectively destroys observers and bindings.
If you try to set a property on a destroyed object, an exception will be raised.
Note that destruction is scheduled for the end of the run loop and does not happen immediately. It will set an isDestroying flag immediately.
didReceiveAttrs public
Inherited from Component packages/ember-glimmer/lib/component.ts:757
Available since v1.13.0
Called when the attributes passed into the component have been updated. Called both during the initial render of a container and during a rerender. Can be used in place of an observer; code placed here will be executed every time any attribute updates.
didRender public
Inherited from Component packages/ember-glimmer/lib/component.ts:777
Available since v1.13.0
Called after a component has been rendered, both on initial render and in subsequent rerenders.
didUpdate public
Inherited from Component packages/ember-glimmer/lib/component.ts:841
Available since v1.13.0
Called when the component has updated and rerendered itself. Called only during a rerender, not during an initial render.
didUpdateAttrs public
Inherited from Component packages/ember-glimmer/lib/component.ts:809
Available since v1.13.0
Called when the attributes passed into the component have been changed. Called only during a rerender, not during an initial render.
get (keyName) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:94
- keyName
- String
The property to retrieve
- returns
- Object
The property value or undefined.
Retrieves the value of a property from the object.
This method is usually similar to using object[keyName]
or object.keyName
,
however it supports both computed properties and the unknownProperty
handler.
Because get
unifies the syntax for accessing all these kinds
of properties, it can make many refactorings easier, such as replacing a
simple property with a computed property, or vice versa.
Computed Properties
Computed properties are methods defined with the property
modifier
declared at the end, such as:
fullName: Ember.computed('firstName', 'lastName', function() {
return this.get('firstName') + ' ' + this.get('lastName');
})
When you call get
on a computed property, the function will be
called and the return value will be returned instead of the function
itself.
Unknown Properties
Likewise, if you try to call get
on a property whose value is
undefined
, the unknownProperty()
method will be called on the object.
If this method returns any value other than undefined
, it will be returned
instead. This allows you to implement "virtual" properties that are
not defined upfront.
getProperties (list) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:137
- list
- String...|Array
of keys to get
- returns
- Object
To get the values of multiple properties at once, call getProperties
with a list of strings or an array:
record.getProperties('firstName', 'lastName', 'zipCode');
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
is equivalent to:
record.getProperties(['firstName', 'lastName', 'zipCode']);
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
getWithDefault (keyName, defaultValue) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:414
- keyName
- String
The name of the property to retrieve
- defaultValue
- Object
The value to return if the property value is undefined
- returns
- Object
The property value or the defaultValue.
Retrieves the value of a property, or a default value in the case that the
property returns undefined
.
person.getWithDefault('lastName', 'Doe');
has (name) : Boolean public
Inherited from Evented packages/ember-runtime/lib/mixins/evented.js:145
- name
- String
The name of the event
- returns
- Boolean
does the object have a subscription for event
Checks to see if object has any subscriptions for named event.
incrementProperty (keyName, increment) : Number public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:432
- keyName
- String
The name of the property to increment
- increment
- Number
The amount to increment by. Defaults to 1
- returns
- Number
The new property value
Set the value of a property to the current value plus some amount.
person.incrementProperty('age');
team.incrementProperty('score', 2);
init public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:210
An overridable method called when objects are instantiated. By default, does nothing unless it is overridden during class definition.
Example:
const Person = Ember.Object.extend({
init() {
alert(`Name is ${this.get('name')}`);
}
});
let steve = Person.create({
name: 'Steve'
});
// alerts 'Name is Steve'.
NOTE: If you do override init
for a framework class like Ember.View
,
be sure to call this._super(...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.
notifyPropertyChange (keyName) : Observable public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:316
- keyName
- String
The property key to be notified about.
- returns
- Observable
Convenience method to call propertyWillChange
and propertyDidChange
in
succession.
off (name, target, method) : public
Inherited from Evented packages/ember-runtime/lib/mixins/evented.js:130
- name
- String
The name of the event
- target
- Object
The target of the subscription
- method
- Function
The function of the subscription
- returns
this
Cancels subscription for given name, target, and method.
on (name, target, method) : public
Inherited from Evented packages/ember-runtime/lib/mixins/evented.js:55
- name
- String
The name of the event
- target
- Object
The "this" binding for the callback
- method
- Function
The callback to execute
- returns
this
Subscribes to a named event with given function.
person.on('didLoad', function() {
// fired once the person has loaded
});
An optional target can be passed in as the 2nd argument that will be set as the "this" for the callback. This is a good way to give your function access to the object triggering the event. When the target parameter is used the callback becomes the third argument.
one (name, target, method) : public
Inherited from Evented packages/ember-runtime/lib/mixins/evented.js:81
- name
- String
The name of the event
- target
- Object
The "this" binding for the callback
- method
- Function
The callback to execute
- returns
this
Subscribes a function to a named event and then cancels the subscription
after the first time the event is triggered. It is good to use one
when
you only care about the first time an event has taken place.
This function takes an optional 2nd argument that will become the "this" value for the callback. If this argument is passed then the 3rd argument becomes the function.
readDOMAttr (name) : public
Inherited from Component packages/ember-glimmer/lib/component.ts:645
- name
- String
the name of the attribute
- returns
String
Normally, Ember's component model is "write-only". The component takes a bunch of attributes that it got passed in, and uses them to render its template.
One nice thing about this model is that if you try to set a value to the same thing as last time, Ember (through HTMLBars) will avoid doing any work on the DOM.
This is not just a performance optimization. If an attribute has not
changed, it is important not to clobber the element's "hidden state".
For example, if you set an input's value
to the same value as before,
it will clobber selection state and cursor position. In other words,
setting an attribute is not always idempotent.
This method provides a way to read an element's attribute and also update the last value Ember knows about at the same time. This makes setting an attribute idempotent.
In particular, what this means is that if you get an <input>
element's
value
attribute and then re-render the template with the same value,
it will avoid clobbering the cursor and selection position.
Since most attribute sets are idempotent in the browser, you typically
can get away with reading attributes using jQuery, but the most reliable
way to do so is through this method.
removeObserver (key, target, method) : Ember.Observable public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:382
- key
- String
The key to observe
- target
- Object
The target object to invoke
- method
- String|Function
The method to invoke
- returns
- Ember.Observable
Remove an observer you have previously registered on this object. Pass
the same key, target, and method you passed to addObserver()
and your
target will no longer receive notifications.
rerender public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:122
Renders the view again. This will work regardless of whether the view is already in the DOM or not. If the view is in the DOM, the rendering process will be deferred to give bindings a chance to synchronize.
If children were added during the rendering process using appendChild
,
rerender
will remove them, because they will be added again
if needed by the next render
.
In general, if the display of your view changes, you should modify
the DOM element directly instead of manually calling rerender
, which can
be slow.
send (actionName, context) public
Inherited from Ember.ActionHandler packages/ember-runtime/lib/mixins/action_handler.js:167
- actionName
- String
The action to trigger
- context
- *
a context to send with the action
Triggers a named action on the ActionHandler
. Any parameters
supplied after the actionName
string will be passed as arguments
to the action target function.
If the ActionHandler
has its target
property set, actions may
bubble to the target
. Bubbling happens when an actionName
can
not be found in the ActionHandler
's actions
hash or if the
action target function returns true
.
Example
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
playTheme() {
this.send('playMusic', 'theme.mp3');
},
playMusic(track) {
// ...
}
}
});
sendAction (action, params) public
Inherited from Ember.ActionSupport packages/ember-views/lib/mixins/action_support.js:27
- action
- String
the action to call
- params
- *
arguments for the action
Calls an action passed to a component.
For example a component for playing or pausing music may translate click events into action notifications of "play" or "stop" depending on some internal state of the component:
import Component from '@ember/component';
export default Component.extend({
click() {
if (this.get('isPlaying')) {
this.sendAction('play');
} else {
this.sendAction('stop');
}
}
});
The actions "play" and "stop" must be passed to this play-button
component:
{{! app/templates/application.hbs }}
{{play-button play=(action "musicStarted") stop=(action "musicStopped")}}
When the component receives a browser click
event it translate this
interaction into application-specific semantics ("play" or "stop") and
calls the specified action.
import Controller from '@ember/controller';
export default Controller.extend({
actions: {
musicStarted() {
// called when the play button is clicked
// and the music started playing
},
musicStopped() {
// called when the play button is clicked
// and the music stopped playing
}
}
});
If no action is passed to sendAction
a default name of "action"
is assumed.
import Component from '@ember/component';
export default Component.extend({
click() {
this.sendAction();
}
});
{{! app/templates/application.hbs }}
{{next-button action=(action "playNextSongInAlbum")}}
import Controller from '@ember/controller';
export default Controller.extend({
actions: {
playNextSongInAlbum() {
...
}
}
});
set (keyName, value) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:162
- keyName
- String
The property to set
- value
- Object
The value to set or
null
.- returns
- Object
The passed value
Sets the provided key or path to the value.
record.set("key", value);
This method is generally very similar to calling object["key"] = value
or
object.key = value
, except that it provides support for computed
properties, the setUnknownProperty()
method and property observers.
Computed Properties
If you try to set a value on a key that has a computed property handler
defined (see the get()
method for an example), then set()
will call
that method, passing both the value and key instead of simply changing
the value itself. This is useful for those times when you need to
implement a property that is composed of one or more member
properties.
Unknown Properties
If you try to set a value on a key that is undefined in the target
object, then the setUnknownProperty()
handler will be called instead. This
gives you an opportunity to implement complex "virtual" properties that
are not predefined on the object. If setUnknownProperty()
returns
undefined, then set()
will simply set the value on the object.
Property Observers
In addition to changing the property, set()
will also register a property
change with the object. Unless you have placed this call inside of a
beginPropertyChanges()
and endPropertyChanges(),
any "local" observers
(i.e. observer methods declared on the same object), will be called
immediately. Any "remote" observers (i.e. observer methods declared on
another object) will be placed in a queue and called at a later time in a
coalesced manner.
setProperties (hash) : Object public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:211
- hash
- Object
the hash of keys and values to set
- returns
- Object
The passed in hash
Sets a list of properties at once. These properties are set inside
a single beginPropertyChanges
and endPropertyChanges
batch, so
observers will be buffered.
record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
toString : String public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:498
- returns
- String
string representation
Returns a string representation which attempts to provide more information
than Javascript's toString
typically does, in a generic way for all Ember
objects.
const Person = Ember.Object.extend()
person = Person.create()
person.toString() //=> "<Person:ember1024>"
If the object's class is not defined on an Ember namespace, it will indicate it is a subclass of the registered superclass:
const Student = Person.extend()
let student = Student.create()
student.toString() //=> "<(subclass of Person):ember1025>"
If the method toStringExtension
is defined, its return value will be
included in the output.
const Teacher = Person.extend({
toStringExtension() {
return this.get('fullName');
}
});
teacher = Teacher.create()
teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
toggleProperty (keyName) : Boolean public
Inherited from Observable packages/ember-runtime/lib/mixins/observable.js:472
- keyName
- String
The name of the property to toggle
- returns
- Boolean
The new property value
Set the value of a boolean property to the opposite of its current value.
starship.toggleProperty('warpDriveEngaged');
trigger (name, args) public
Inherited from Evented packages/ember-runtime/lib/mixins/evented.js:107
- name
- String
The name of the event
- args
- Object...
Optional arguments to pass on
Triggers a named event for the object. Any additional arguments will be passed as parameters to the functions that are subscribed to the event.
person.on('didEat', function(food) {
console.log('person ate some ' + food);
});
person.trigger('didEat', 'broccoli');
// outputs: person ate some broccoli
willDestroy public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:471
Override to implement teardown.
willRender public
Inherited from Component packages/ember-glimmer/lib/component.ts:793
Available since v1.13.0
Called before a component has been rendered, both on initial render and in subsequent rerenders.
willUpdate public
Inherited from Component packages/ember-glimmer/lib/component.ts:825
Available since v1.13.0
Called when the component is about to update and rerender itself. Called only during a rerender, not during an initial render.
Properties
actions public
Inherited from Ember.ActionHandler packages/ember-runtime/lib/mixins/action_handler.js:22
The collection of functions, keyed by name, available on this
ActionHandler
as action targets.
These functions will be invoked when a matching {{action}}
is triggered
from within a template and the application's current route is this route.
Actions can also be invoked from other parts of your application
via ActionHandler#send
.
The actions
hash will inherit action handlers from
the actions
hash defined on extended parent classes
or mixins rather than just replace the entire hash, e.g.:
import Mixin from '@ember/mixin';
export default Mixin.create({
actions: {
displayBanner(msg) {
// ...
}
}
});
import Route from '@ember/routing/route';
import CanDisplayBanner from '../mixins/can-display-banner';
export default Route.extend(CanDisplayBanner, {
actions: {
playMusic() {
// ...
}
}
});
// `WelcomeRoute`, when active, will be able to respond
// to both actions, since the actions hash is merged rather
// then replaced when extending mixins / parent classes.
this.send('displayBanner');
this.send('playMusic');
Within a Controller, Route or Component's action handler,
the value of the this
context is the Controller, Route or
Component object:
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
myAction() {
this.controllerFor("song");
this.transitionTo("other.route");
...
}
}
});
It is also possible to call this._super(...arguments)
from within an
action handler if it overrides a handler defined on a parent
class or mixin:
Take for example the following routes:
import Mixin from '@ember/mixin';
export default Ember.Mixin.create({
actions: {
debugRouteInformation() {
console.debug("It's a-me, console.debug!");
}
}
});
import Route from '@ember/routing/route';
import DebugRoute from '../mixins/debug-route';
export default Route.extend(DebugRoute, {
actions: {
debugRouteInformation() {
// also call the debugRouteInformation of mixed in DebugRoute
this._super(...arguments);
// show additional annoyance
window.alert(...);
}
}
});
Bubbling
By default, an action will stop bubbling once a handler defined
on the actions
hash handles it. To continue bubbling the action,
you must return true
from the handler:
Router.map(function() {
this.route("album", function() {
this.route("song");
});
});
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
startPlaying: function() {
}
}
});
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
startPlaying() {
// ...
if (actionShouldAlsoBeTriggeredOnParentRoute) {
return true;
}
}
}
});
ariaRole public
Inherited from Component packages/ember-glimmer/lib/component.ts:681
The WAI-ARIA role of the control represented by this view. For example, a button may have a role of type 'button', or a pane may have a role of type 'alertdialog'. This property is used by assistive software to help visually challenged users navigate rich web applications.
The full list of valid WAI-ARIA roles is available at: http://www.w3.org/TR/wai-aria/roles#roles_categorization
attributeBindings public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:18
A list of properties of the view to apply as attributes. If the property is a string value, the value of that string will be applied as the value for an attribute of the property's name.
The following example creates a tag like <div priority="high" />
.
import Component from '@ember/component';
export default Component.extend({
attributeBindings: ['priority'],
priority: 'high'
});
If the value of the property is a Boolean, the attribute is treated as
an HTML Boolean attribute. It will be present if the property is true
and omitted if the property is false
.
The following example creates markup like <div visible />
.
import Component from '@ember/component';
export default Component.extend({
attributeBindings: ['visible'],
visible: true
});
If you would prefer to use a custom value instead of the property name, you can create the same markup as the last example with a binding like this:
import Component from '@ember/component';
export default Component.extend({
attributeBindings: ['isVisible:visible'],
isVisible: true
});
This list of attributes is inherited from the component's superclasses, as well.
classNameBindings public
Inherited from Ember.ClassNamesSupport packages/ember-views/lib/mixins/class_names_support.js:37
A list of properties of the view to apply as class names. If the property is a string value, the value of that string will be applied as a class name.
// Applies the 'high' class to the view element
Ember.Component.extend({
classNameBindings: ['priority'],
priority: 'high'
});
If the value of the property is a Boolean, the name of that property is added as a dasherized class name.
// Applies the 'is-urgent' class to the view element
Ember.Component.extend({
classNameBindings: ['isUrgent'],
isUrgent: true
});
If you would prefer to use a custom value instead of the dasherized property name, you can pass a binding like this:
// Applies the 'urgent' class to the view element
Ember.Component.extend({
classNameBindings: ['isUrgent:urgent'],
isUrgent: true
});
This list of properties is inherited from the component's superclasses as well.
classNames public
Inherited from Ember.ClassNamesSupport packages/ember-views/lib/mixins/class_names_support.js:25
Standard CSS class names to apply to the view's outer element. This property automatically inherits any class names defined by the view's superclasses as well.
concatenatedProperties public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:248
Defines the properties that will be concatenated from the superclass (instead of overridden).
By default, when you extend an Ember class a property defined in
the subclass overrides a property with the same name that is defined
in the superclass. However, there are some cases where it is preferable
to build up a property's value by combining the superclass' property
value with the subclass' value. An example of this in use within Ember
is the classNames
property of Ember.View
.
Here is some sample code showing the difference between a concatenated property and a normal one:
const Bar = Ember.Object.extend({
// Configure which properties to concatenate
concatenatedProperties: ['concatenatedProperty'],
someNonConcatenatedProperty: ['bar'],
concatenatedProperty: ['bar']
});
const FooBar = Bar.extend({
someNonConcatenatedProperty: ['foo'],
concatenatedProperty: ['foo']
});
let fooBar = FooBar.create();
fooBar.get('someNonConcatenatedProperty'); // ['foo']
fooBar.get('concatenatedProperty'); // ['bar', 'foo']
This behavior extends to object creation as well. Continuing the above example:
let fooBar = FooBar.create({
someNonConcatenatedProperty: ['baz'],
concatenatedProperty: ['baz']
})
fooBar.get('someNonConcatenatedProperty'); // ['baz']
fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
Adding a single property that is not an array will just add it in the array:
let fooBar = FooBar.create({
concatenatedProperty: 'baz'
})
view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
Using the concatenatedProperties
property, we can tell Ember to mix the
content of the properties.
In Ember.Component
the classNames
, classNameBindings
and
attributeBindings
properties are concatenated.
This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).
element public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:147
Returns the current DOM element for the view.
elementId public
Inherited from Component packages/ember-glimmer/lib/component.ts:886
The HTML id
of the component's element in the DOM. You can provide this
value yourself but it must be unique (just as in HTML):
{{my-component elementId="a-really-cool-id"}}
If not manually set a default value will be provided by the framework.
Once rendered an element's elementId
is considered immutable and you
should never change it. If you need to compute a dynamic value for the
elementId
, you should do this when the component or element is being
instantiated:
export default Component.extend({
init() {
this._super(...arguments);
var index = this.get('index');
this.set('elementId', `component-id${index}`);
}
});
isDestroyed public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:395
Destroyed object property flag.
if this property is true
the observers and bindings were already
removed by the effect of calling the destroy()
method.
isDestroying public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:420
Destruction scheduled flag. The destroy()
method has been called.
The object stays intact until the end of the run loop at which point
the isDestroyed
flag is set.
isVisible public
Inherited from Component packages/ember-glimmer/lib/component.ts:915
If false
, the view will appear hidden in DOM.
layout public
Inherited from Component packages/ember-glimmer/lib/component.ts:857
Layout can be used to wrap content in a component.
mergedProperties public
Inherited from CoreObject packages/ember-runtime/lib/system/core_object.js:321
Defines the properties that will be merged from the superclass (instead of overridden).
By default, when you extend an Ember class a property defined in
the subclass overrides a property with the same name that is defined
in the superclass. However, there are some cases where it is preferable
to build up a property's value by merging the superclass property value
with the subclass property's value. An example of this in use within Ember
is the queryParams
property of routes.
Here is some sample code showing the difference between a merged property and a normal one:
const Bar = Ember.Object.extend({
// Configure which properties are to be merged
mergedProperties: ['mergedProperty'],
someNonMergedProperty: {
nonMerged: 'superclass value of nonMerged'
},
mergedProperty: {
page: { replace: false },
limit: { replace: true }
}
});
const FooBar = Bar.extend({
someNonMergedProperty: {
completelyNonMerged: 'subclass value of nonMerged'
},
mergedProperty: {
limit: { replace: false }
}
});
let fooBar = FooBar.create();
fooBar.get('someNonMergedProperty');
// => { completelyNonMerged: 'subclass value of nonMerged' }
//
// Note the entire object, including the nonMerged property of
// the superclass object, has been replaced
fooBar.get('mergedProperty');
// => {
// page: {replace: false},
// limit: {replace: false}
// }
//
// Note the page remains from the superclass, and the
// `limit` property's value of `false` has been merged from
// the subclass.
This behavior is not available during object create
calls. It is only
available at extend
time.
In Ember.Route
the queryParams
property is merged.
This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual merged property (to not mislead your users to think they can override the property in a subclass).
positionalParams public
Inherited from Component packages/ember-glimmer/lib/component.ts:696
Available since v1.13.0
Enables components to take a list of parameters as arguments.
For example, a component that takes two parameters with the names
name
and age
:
import Component from '@ember/component';
let MyComponent = Component.extend();
MyComponent.reopenClass({
positionalParams: ['name', 'age']
});
export default MyComponent;
It can then be invoked like this:
{{my-component "John" 38}}
The parameters can be referred to just like named parameters:
Name: {{name}}, Age: {{age}}.
Using a string instead of an array allows for an arbitrary number of parameters:
import Component from '@ember/component';
let MyComponent = Component.extend();
MyComponent.reopenClass({
positionalParams: 'names'
});
export default MyComponent;
It can then be invoked like this:
{{my-component "John" "Michael" "Scott"}}
The parameters can then be referred to by enumerating over the list:
{{#each names as |name|}}{{name}}{{/each}}
tagName public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:373
Tag name for the view's outer element. The tag name is only used when an
element is first created. If you change the tagName
for an element, you
must destroy and recreate the view element.
By default, the render buffer will use a <div>
tag for views.
Events
didInsertElement public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:311
Called when the element of the view has been inserted into the DOM. Override this function to do any set up that requires an element in the document body.
When a view has children, didInsertElement will be called on the child view(s) first and on itself afterwards.
didReceiveAttrs public
Inherited from Component packages/ember-glimmer/lib/component.ts:767
Available since v1.13.0
Called when the attributes passed into the component have been updated. Called both during the initial render of a container and during a rerender. Can be used in place of an observer; code placed here will be executed every time any attribute updates.
didRender public
Inherited from Component packages/ember-glimmer/lib/component.ts:785
Available since v1.13.0
Called after a component has been rendered, both on initial render and in subsequent rerenders.
didUpdate public
Inherited from Component packages/ember-glimmer/lib/component.ts:849
Available since v1.13.0
Called when the component has updated and rerendered itself. Called only during a rerender, not during an initial render.
didUpdateAttrs public
Inherited from Component packages/ember-glimmer/lib/component.ts:817
Available since v1.13.0
Called when the attributes passed into the component have been changed. Called only during a rerender, not during an initial render.
willClearRender public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:324
Called when the view is about to rerender, but before anything has been torn down. This is a good opportunity to tear down any manual observers you have installed based on the DOM state
willDestroyElement public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:348
Called when the element of the view is going to be destroyed. Override this function to do any teardown that requires an element, like removing event listeners.
Please note: any property changes made during this event will have no effect on object observers.
willInsertElement public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:303
Called when a view is going to insert an element into the DOM.
willRender public
Inherited from Component packages/ember-glimmer/lib/component.ts:801
Available since v1.13.0
Called before a component has been rendered, both on initial render and in subsequent rerenders.
willUpdate public
Inherited from Component packages/ember-glimmer/lib/component.ts:833
Available since v1.13.0
Called when the component is about to update and rerender itself. Called only during a rerender, not during an initial render.