Adds an attribute with the provided configuration to the host object.

The config argument object supports the following properties:

value <Any>

The initial value to set on the attribute

valueFn <Function | String>

A function, which will return the initial value to set on the attribute. This is useful for cases where the attribute configuration is defined statically, but needs to reference the host instance ("this") to obtain an initial value. If both the value and valueFn properties are defined, the value returned by the valueFn has precedence over the value property, unless it returns undefined, in which case the value property is used.

valueFn can also be set to a string, representing the name of the instance method to be used to retrieve the value.

readOnly <boolean>

Whether or not the attribute is read only. Attributes having readOnly set to true cannot be modified by invoking the set method.

writeOnce <boolean> or <string>

Whether or not the attribute is "write once". Attributes having writeOnce set to true, can only have their values set once, be it through the default configuration, constructor configuration arguments, or by invoking set.

The writeOnce attribute can also be set to the string "initOnly", in which case the attribute can only be set during initialization (when used with Base, this means it can only be set during construction)

setter <Function | String>

The setter function used to massage or normalize the value passed to the set method for the attribute. The value returned by the setter will be the final stored value. Returning Attribute.INVALID_VALUE, from the setter will prevent the value from being stored.

setter can also be set to a string, representing the name of the instance method to be used as the setter function.

getter <Function | String>

The getter function used to massage or normalize the value returned by the get method for the attribute. The value returned by the getter function is the value which will be returned to the user when they invoke get.

getter can also be set to a string, representing the name of the instance method to be used as the getter function.

validator <Function | String>

The validator function invoked prior to setting the stored value. Returning false from the validator function will prevent the value from being stored.

validator can also be set to a string, representing the name of the instance method to be used as the validator function.

lazyAdd <boolean>

Whether or not to delay initialization of the attribute until the first call to get/set it. This flag can be used to over-ride lazy initialization on a per attribute basis, when adding multiple attributes through the addAttrs method.

The setter, getter and validator are invoked with the value and name passed in as the first and second arguments, and with the context ("this") set to the host object.

Configuration properties outside of the list mentioned above are considered private properties used internally by attribute, and are not intended for public use.

Configures a group of attributes, and sets initial values.

NOTE: This method does not isolate the configuration object by merging/cloning. The caller is responsible for merging/cloning the configuration object if required.

Registers another EventTarget as a bubble target. Bubble order is determined by the order registered. Multiple targets can be specified.

Events can only bubble if emitFacade is true.

Included in the event-custom-complex submodule.

Subscribe to a custom event hosted by this object. The supplied callback will execute after any listeners add via the subscribe method, and after the default function, if configured for the event, has executed.

Attaches delegated event handlers to this view's container element. This method is called internally to subscribe to events configured in the events attribute when the view is initialized.

You may override this method to customize the event attaching logic.

Checks if the given attribute has been added to the host

Executes the callback before a DOM event, custom event or method. If the first argument is a function, it is assumed the target is a method. For DOM and custom events, this is an alias for Y.on.

For DOM and custom events: type, callback, context, 0-n arguments

For methods: callback, object (method host), methodName, context, 0-n arguments

Propagate an event. Requires the event-custom-complex module.

Creates and returns a container node for this view.

By default, the container is created from the HTML template specified in the containerTemplate property, and is not added to the DOM automatically.

You may override this method to customize how the container node is created (such as by rendering it from a custom template format). Your method must return a Y.Node instance.

Destroys this View, detaching any DOM events and optionally also destroying its container node.

By default, the container node will not be destroyed. Pass an options object with a truthy remove property to destroy the container as well.

Detach one or more listeners the from the specified event

Removes all listeners from the specified event. If the event type is not specified, all listeners from all hosted custom events will be removed.

Detaches DOM events that have previously been attached to the container by attachEvents().

Dispatches to the first route handler that matches the current URL, if any.

If dispatch() is called before the ready event has fired, it will automatically wait for the ready event before dispatching. Otherwise it will dispatch immediately.

Fire a custom event by name. The callback functions will be executed from the context specified when the event was created, and with the following parameters.

The first argument is the event type, and any additional arguments are passed to the listeners as parameters. If the first of these is an object literal, and the event is configured to emit an event facade, that object is mixed into the event facade and the facade is provided in place of the original object.

If the custom event object hasn't been created, then the event hasn't been published and it has no subscribers. For performance sake, we immediate exit in this case. This means the event won't bubble, so if the intention is that a bubble target be notified, the event must be published on this object first.

Returns the current value of the attribute. If the attribute has been configured with a 'getter' function, this method will delegate to the 'getter' to obtain the value of the attribute.

Gets multiple attribute values.

Returns the custom event of the provided type has been created, a falsy value otherwise

Gets the current route path.

Returns an array of bubble targets for this object.

Returns true if this router has at least one route that matches the specified URL, false otherwise. This also checks that any named param handlers also accept app param values in the url.

This method enforces the same-origin security constraint on the specified url; any URL which is not from the same origin as the current URL will always return false.

Init lifecycle method, invoked during construction. Sets up attributes and invokes initializers for the class hierarchy.

Returns an array of route objects that match the specified URL path.

If this router has a root, then the specified path must be semantically within the root path to match any routes.

This method is called internally to determine which routes match the current path whenever the URL changes. You may override it if you want to customize the route matching logic, although this usually shouldn't be necessary.

Each returned route object has the following properties:

• callback: A function or a string representing the name of a function this router that should be executed when the route is triggered.

• keys: An array of strings representing the named parameters defined in the route's path specification, if any.

• path: The route's path specification, which may be either a string or a regex.

• regex: A regular expression version of the route's path specification. This regex is used to determine whether the route matches a given path.

Updates the configuration of an attribute which has already been added.

The properties which can be modified through this interface are limited to the following subset of attributes, which can be safely modified after a value has already been set on the attribute:

readOnly;

writeOnce;

broadcast; and

getter.

Note: New attributes cannot be added using this interface. New attributes must be added using addAttr, or an appropriate manner for a class which utilises Attributes (e.g. the ATTRS property in Base).

Subscribe a callback function to a custom event fired by this object or from an object that bubbles its events to this object.

 this.on("change", this._onChange, this);

Callback functions for events published with emitFacade = true will receive an EventFacade as the first argument (typically named "e"). These callbacks can then call e.preventDefault() to disable the behavior published to that event's defaultFn. See the EventFacade API for all available properties and methods. Subscribers to non-emitFacade events will receive the arguments passed to fire() after the event name.

To subscribe to multiple events at once, pass an object as the first argument, where the key:value pairs correspond to the eventName:callback.

 this.on({
     "attrChange" : this._onAttrChange,
     "change"     : this._onChange
 });

You can also pass an array of event names as the first argument to subscribe to all listed events with the same callback.

 this.on([ "change", "attrChange" ], this._onChange);

Returning false from a callback is supported as an alternative to calling e.preventDefault(); e.stopPropagation();. However, it is recommended to use the event methods whenever possible.

Listen to a custom event hosted by this object one time. This is the equivalent to on except the listener is immediatelly detached when it is executed.

Listen to a custom event hosted by this object one time. This is the equivalent to after except the listener is immediatelly detached when it is executed.

Adds a handler for a route param specified by name.

Param handlers can be registered via this method and are used to validate/format values of named params in routes before dispatching to the route's handler functions. Using param handlers allows routes to defined using string paths which allows for req.params to use named params, but still applying extra validation or formatting to the param values parsed from the URL.

If a param handler regex or function returns a value of false, null, undefined, or NaN, the current route will not match and be skipped. All other return values will be used in place of the original param value parsed from the URL.

Takes the type parameter passed to 'on' and parses out the various pieces that could be included in the type. If the event type is passed without a prefix, it will be expanded to include the prefix one is supplied or the event target is configured with a default prefix.

Creates a new custom event of the specified type. If a custom event by that name already exists, it will not be re-created. In either case the custom event is returned.

Removes this view's container element from the DOM (if it's in the DOM), but doesn't destroy it or any event listeners attached to it.

Removes an attribute from the host object

Removes a query string from the end of the url (if one exists) and returns the result.

Removes the root URL from the front of url (if it's there) and returns the result. The returned path will always have a leading /.

Removes a bubble target

Replaces the current browser history entry with a new one, and dispatches to the first matching route handler, if any.

Behind the scenes, this method uses HTML5 pushState() in browsers that support it (or the location hash in older browsers and IE) to change the URL.

The specified URL must share the same origin (i.e., protocol, host, and port) as the current page, or an error will occur.

Resets the attribute (or all attributes) to its initial value, as long as the attribute is not readOnly, or writeOnce.

Adds a route handler for the specified route.

The route parameter may be a string or regular expression to represent a URL path, or a route object. If it's a string (which is most common), it may contain named parameters: :param will match any single part of a URL path (not including / characters), and *param will match any number of parts of a URL path (including / characters). These named parameters will be made available as keys on the req.params object that's passed to route handlers.

If the route parameter is a regex, all pattern matches will be made available as numbered keys on req.params, starting with 0 for the full match, then 1 for the first subpattern match, and so on.

Alternatively, an object can be provided to represent the route and it may contain a path property which is a string or regular expression which causes the route to be process as described above. If the route object already contains a regex or regexp property, the route will be considered fully-processed and will be associated with any callacks specified on the object and those specified as parameters to this method. Note: Any additional data contained on the route object will be preserved.

Here's a set of sample routes along with URL paths that they match:

• Route: /photos/:tag/:page

  • URL: /photos/kittens/1, params: {tag: 'kittens', page: '1'}
  • URL: /photos/puppies/2, params: {tag: 'puppies', page: '2'}

• Route: /file/*path

  • URL: /file/foo/bar/baz.txt, params: {path: 'foo/bar/baz.txt'}
  • URL: /file/foo, params: {path: 'foo'}

Middleware: Routes also support an arbitrary number of callback functions. This allows you to easily reuse parts of your route-handling code with different route. This method is liberal in how it processes the specified callbacks, you can specify them as separate arguments, or as arrays, or both.

If multiple route match a given URL, they will be executed in the order they were added. The first route that was added will be the first to be executed.

Passing Control: Invoking the next() function within a route callback will pass control to the next callback function (if any) or route handler (if any). If a value is passed to next(), it's assumed to be an error, therefore stopping the dispatch chain, unless that value is: "route", which is special case and dispatching will skip to the next route handler. This allows middleware to skip any remaining middleware for a particular route.

Saves a new browser history entry and dispatches to the first matching route handler, if any.

Behind the scenes, this method uses HTML5 pushState() in browsers that support it (or the location hash in older browsers and IE) to change the URL and create a history entry.

The specified URL must share the same origin (i.e., protocol, host, and port) as the current page, or an error will occur.

Sets the value of an attribute.

Sets multiple attribute values.

Default toString implementation. Provides the constructor NAME and the instance guid, if set.

Upgrades a hash-based URL to an HTML5 URL if necessary. In non-HTML5 browsers, this method is a noop.