CanJS

Extends the can.Component constructor function with prototype properties and methods.

Called when a new instance of a can.Construct is created.

A setup function for the instantiation of a constructor function.

Extends `can.Construct`, or constructor functions derived from `can.Construct`, to create a new constructor function.

Returns an instance of `can.Construct`.

A static `setup` method provides inheritable setup functionality for a Constructor function.

Creates a static callback function that has `this` set to the constructor function.

Creates a static callback function that has `this` set to an instance of the constructor function.

Calls the base constructor function's method.

Prepares a control for garbage collection and is a place to reset any changes the control has made.

Bind an event handler to a Control, or rebind all event handlers on a Control.

Rebind all of a control's event handlers.

Perform pre-initialization logic.

Create a new, extended, control constructor function.

Render a view object with data and helpers.

Runs JavaScript Code.

Runs JS Code and writes the _escaped_ result into the result of the template.

Runs JS Code and writes the _unescaped_ result into the result of the template.

Renders <% CODE %> as text in result of the template rather than running CODE itself.

Used for explicitly for comments.

Gets an array of all the elements in this `can.List`.

Reads an element from this `can.List`.

Assigns _value_ to the index _index_ on this `can.List`, expanding the list if necessary.

Merges the members of _elements_ into this List, replacing each from the beginning in order.

Merge many collections together into a List.

Call a function for each element of a List.

`indexOf` finds the position of a given item in the List.

`join` turns a List into a string by inserting _separator_ between the string representations of all the elements of the List.

`push` removes an element from the end of a List.

`push` adds elements onto the end of a List.]

Replace all the elements of a List.

`reverse` reverses the elements of the List in place.

`shift` removes an element from the beginning of a List.

`slice` creates a copy of a portion of the List.

Insert and remove elements from a List.

`unshift` adds elements onto the beginning of a List.

Gets a collection of all the properties in this `can.Map`.

Reads a property from this `can.Map`.

Assigns _value_ to a property on this `can.Map` called _key_.

Assigns each value in _obj_ to a property on this `can.Map` named after the corresponding key in _obj_, effectively merging _obj_ into the Map.

Bind event handlers to an Map.

Make a can.compute from an observable property.

`each` iterates through the Map, calling a function for each property value and key.

Remove a property from an Map.

Get the serialized Object form of the map.

Unbind event handlers from an Map.

Iterate over the keys of an Map.

Listen to events on this Model.

Destroy a Model on the server.

Check if a Model has yet to be saved on the server.

Save a model back to the server.

Stop listening to events on this Model.

Listen for events on a Model class.

Specify a function to create persistent instances.

Specify a HTTP method and url to create persistent instances.

Specify an options object that is used to make a HTTP request to create persistent instances.

If you provide a function, the Model will expect you to do your own AJAX requests.

If you provide a URL, the Model will send a request to that URL using the method specified (or DELETE if none is specified) when deleting an instance on the server.

Retrieve multiple resources from a server.

Implements `findAll` with a function.

Implements `findAll` with a HTTP method and url to retrieve instance data.

Implements `findAll` with a ajax settings object.

Retrieve a single instance from the server.

Implements `findOne` with a function.

Implements `findOne` with a HTTP method and url to retrieve an instance's data.

Implements `findOne` with a ajax settings object.

Returns the external `findAll` method given the implemented findAllData function.

Returns the external `findOne` method given the implemented findOneData function.

Convert raw data into a can.Model instance.

Creates a `model` function that looks for the attributes object in the PROPERTY property of raw instance data.

Convert raw data into can.Model instances.

Creates a `models` function that looks for the array of instance data in the PROPERTY property of the raw response data of findAll.

Stop listening for events on a Model class.

If you provide a URL, the Model will send a request to that URL using the method specified (or PUT if none is specified) when updating an instance on the server.

If you provide a function, the Model will expect you to do your own AJAX requests.

Register a helper.

Insert the value of the key into the output of the template.

Behaves just like {{key}} and {{helper}} but does not escape the result.

The `{{&key}}` tag is an alias for {{{key}}}, behaving just like {{key}} and {{helper}} but does not escape the result.

Render blocks of text one or more times, depending on the value of the key in the current context.

Ends a {{#key}} or {{#helper}} block.

Render blocks of text if the value of the key is falsey.

Render another template within the current template.

The comment tag operates similarly to a `` tag in HTML.

Calls a mustache helper function or a function.

Calls a mustache helper function or a function with a block to render.

Calls a mustache helper function or a function with a `fn` and `inverse` block to render.

Renders the `BLOCK` template within the current template.

Creates an `inverse` block for a helper function's options argument's `inverse` property.

Render the block of text if the key's value is falsey.

Render the block of text for each item in key's value.

Changes the context within a block.

Adds the current context to the element's can.data.

Executes an element callback with the inline code on the element.

Logs the context of the current block with an optional message.

Insert the index of an Array or can.List we are iterating on with [#each](can.Mustache.helpers.each)

Insert the property name of an Object or attribute name of a can.Map that we iterate over with [#each](can.Mustache.helpers.each)

Check if data represents the current route.

Extract data from a route path.

Make an anchor tag (``) that when clicked on will update can.route's properties to match those in `data`.

Get a route path from given data.

Sets up the two-way binding between the hash and the can.route observable map and sets the can.route map to its initial values.

Make a URL fragment that when set to window.location.hash will update can.route's properties to match those in `data`.

Begin an event batch.

End an event batch.

Trigger an event to be added to the current batch.

Create a lookup node for keys.

Register an EJS template string and create a renderer function.

Create a hookup to insert into templates.

Register a Mustache template string and create a renderer function.

Register a templating language.

Render a template.

Render a template.