cortex.js

# API documentation --------------------------------------- ### Cortex.version Expose the current version number of the Cortex Library. --------------------------------------- ### Cortex.noConflict(selector _Boolean_) Simple conflict handling if we are overriding the $ or other Cortex instances. Basically, if you need this function you are doing something wrong. #### Arguments - **selector** _Boolean_ $ selector only --------------------------------------- ### Cortex.is(type _Mixed_, expected _String_) Simple type checking. #### Arguments - **type** _Mixed_ - **expected** _String_ --------------------------------------- ### Cortex.forEach(collection _Mixed_, iterator _Function_, context _Mixed_) Cortex.forEach is a simple iterator. Iterations should be delegated to the Native functions when ever possible. #### Arguments - **collection** _Mixed_ - **iterator** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.filter(collection _Mixed_, iterator _Function_, context _Mixed_) Cortex.filter returns all elements that pass the truth test. Filtering should be delegated to native function when ever possible. #### Arguments - **collection** _Mixed_ - **iterator** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.map(collection _Mixed_, iterator _Function_, context _Mixed_) Cortex.map returns the results of applying the iterator to each item in the collection. #### Arguments - **collection** _Mixed_ - **iterator** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.matchesSelector(selector _String_, element _DOM_) MatchesSelector, simple checking if a DOM element matches a certain CSS selector. This method is used internally for Event Listening. #### Arguments - **selector** _String_ - **element** _DOM_ --------------------------------------- ### Cortex.extend(obj _Object_) Extend the given object with all the properties of the supplied arguments. #### Arguments - **obj** _Object_ the base object that needs to be extended with all args --------------------------------------- ### Cortex.property(obj _Object_, prop _String_) Helper function to get the value from an object as property. If the property is a function it will be executed instead. #### Arguments - **obj** _Object_ - **prop** _String_ --------------------------------------- ### Cortex.EventEmitter Cortex.EventEmitter is heavily influenced by the Node.js EventEmitter module and the regular Observer pattern. It does have some level of compatibility with the Node.js EventEmitter but don't depend on the same behaviour, the API's are just the same. --------------------------------------- ### Cortex.on(events _String_, callback _Function_, context _Mixed_) Adds an event listener. #### Arguments - **events** _String_ space separated list of events to listen on - **callback** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.off(event _String_, callback _Function_, context _Mixed_) Removes attached event listeners. If no arguments are supplied it will remove all the assigned events. If no callback is supplied it will remove all listeners for the specified events. If no context is provided it will remove all event listeners that have the supplied callback. #### Arguments - **event** _String_ - **callback** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.remove(handle _Function_) Helper function to filter out the <code>this.events</code> array #### Arguments - **handle** _Function_ the callback of the event --------------------------------------- ### Cortex.emit(event _String_) Call the supplied event listeners with all the supplied arguments. #### Arguments - **event** _String_ --------------------------------------- ### Cortex.once(event _String_, callback _Function_, context _Mixed_) Create a listeners that is only called once. #### Arguments - **event** _String_ - **callback** _Function_ - **context** _Mixed_ --------------------------------------- ### Cortex.enable() Enable the EventEmitter. --------------------------------------- ### Cortex.disable() Disable the EventEmitter. --------------------------------------- ### Cortex.Structure The Cortex.Structure The Cortex Model is a light-weight implementation of the Backbone.js model and is designed to be used a wrapper for the DOM and for Objects so we have one single universal structure for all operations. Which will hopefully help us to keep our code sane. --------------------------------------- ### Structure.get(attr _String_) Get attributes from the structure #### Arguments - **attr** _String_ --------------------------------------- ### Structure.has(attr _String_) See if we have this attribute. We use the #get method for checking as it's easier to extend the structure this way. #### Arguments - **attr** _String_ --------------------------------------- ### Structure.set(key _String_, value _Mixed_, options _Object_) Set new attributes in the structure. #### Arguments - **key** _String_ - **value** _Mixed_ - **options** _Object_ --------------------------------------- ### Structure.remove(attr _String_) Remove attributes from the structure. #### Arguments - **attr** _String_ --------------------------------------- ### Structure.clear() Clear all attributes of the structure. --------------------------------------- ### Structure.clone() Create a new clone of the model that is identical to this one. --------------------------------------- ### Structure.previous(attr _String_) Get the previous attributes. #### Arguments - **attr** _String_ attribute that we want the old value from. --------------------------------------- ### Structure.parse(obj _Object_) Parse converts the given attributes of an Structure to an Object. #### Arguments - **obj** _Object_ --------------------------------------- ### Structure.plain(index _Mixed_, options _Object_) Transform the Model to a regular plain JavaScript structure. #### Arguments - **index** _Mixed_ the index of the array or key that it should return - **options** _Object_ --------------------------------------- ### Cortex.Collection(structures _Array_, options _Object_) Cortex.Collection: Provides a standard collection class for a set of Structure. #### Arguments - **structures** _Array_ - **options** _Object_ --------------------------------------- ### Collection.structure The default structure for a collection is just a plain Structure --------------------------------------- ### Collection.plain(index _Mixed_, options _Object_) Transform the collection in a plain object structure. #### Arguments - **index** _Mixed_ - **options** _Object_ --------------------------------------- ### Collection.add(structures _Mixed_, options _Object_) Add a new Structure or an Array of Structures to the collections. #### Arguments - **structures** _Mixed_ - **options** _Object_ --------------------------------------- ### Collection.remove(structures _Mixed_, options _Object_) Removes a structure from the collection. #### Arguments - **structures** _Mixed_ - **options** _Object_ --------------------------------------- ### Collection.has(obj _Mixed_, options _Object_) Checks if the Collection has the given structure. #### Arguments - **obj** _Mixed_ - **options** _Object_ --------------------------------------- ### Collection.get(id _Mixed_) Get a structure by id. #### Arguments - **id** _Mixed_ --------------------------------------- ### Collection.prepare(structure _Mixed_, options _Object_) Prepare a structure so it can be used in a Collection context, if we don't receive a Structure instance we are going to generate a new one. #### Arguments - **structure** _Mixed_ - **options** _Object_ --------------------------------------- ### Collection.parse(obj _Array_) Parse the data that is added to the to collection #### Arguments - **obj** _Array_ --------------------------------------- ### Collection.{forEach, each, map, collect, filter, select} Assign Cortex methods that we want to assign to our collection. --------------------------------------- ### Cortex.View(options _Object_) Cortex.View: A simple application view handler. #### Arguments - **options** _Object_ --------------------------------------- ### View.selector The default selector that we should create if we don't have a Node reference. --------------------------------------- ### View.delegated Event delegated. --------------------------------------- ### View.$(selector _String_) Find new elements #### Arguments - **selector** _String_ --------------------------------------- ### View.template(name _String_, data _Object_) Provides an alternate syntax for plates which provides you with a chained syntax: ```js this.template('name', data).where('href').has('/bar').insert('newurl'); ``` #### Arguments - **name** _String_ name of the template file - **data** _Object_ data for the template --------------------------------------- ### Cortex.Node Cortex.Node: Cortex.Node is an DOM interface allows us to create a universal interface between the DOM and our application code. This is where can add support for different DOM operations such as a <code>css</code> method etc. --------------------------------------- ### Node.get(attr _String_) Get attributes attributes from the given Node instance. #### Arguments - **attr** _String_ --------------------------------------- ### Node.set(key _String_, value _String_, options _Object_) Set's new attributes on the Node instance, if an element doesn't support it, it should should really be added as data-attribute. - **key** _String_ Attribute that should be updated - **value** _String_ The value that should be set - **options** _Object_ --------------------------------------- ### Node.factory(dom _String_) Generate an actual DOM element from a string. #### Arguments - **dom** _String_ --------------------------------------- ### Node.destroy() Destroy the structure. --------------------------------------- This is where the syntax sugar starts. If you want to interact with the DOM in any way this is the spot where you would want to be. Make sure that every single function that is specified here returns <code>this</code> so we can chain different methods together. --------------------------------------- ### Node.show() Show the DOM element. --------------------------------------- ### Node.hide() Hide the DOM element. --------------------------------------- ### Node.addClass(className _String_) Added classNames #### Arguments - **className** _String_ --------------------------------------- ### Node.removeClass(className _String_) remove className. #### Arguments - **className** _String_ --------------------------------------- ### Cortex.Nodelist Cortex.Nodelist: A simple representation of a Node collection. --------------------------------------- ### Nodelist.structure The default Structure that should be created. Defaults to Node --------------------------------------- ### Nodelist.selector The selector that was used to generate this Nodelist --------------------------------------- ### Nodelist.find(selector _String_) Generate a new Nodelist instance with the matching Nodes. #### Arguments - **selector** _String_ --------------------------------------- ### Nodelist.end() End a chained .find() method by returning it's wrapping parent Nodelist --------------------------------------- ### Nodelist.parent(selector _String_) Find the parent of the element. #### Arguments - **selector** _String_ optional selector to that it should match --------------------------------------- ### Nodelist.{show, hide, addClass, removeClass, get, set, destroy} Generate proxy methods to the Node structure --------------------------------------- ### Cortex.Events Cortex.Events: Cortex.Events takes care of all the DOM event handling. All events DOM events eventually bubble down to the documentElement where they are captured and checked against CSS selectors for events that are listening. --------------------------------------- ### Events.listeners Simple dictionary that contains all our listeners. --------------------------------------- ### Events.add(type _String_, selectors _String_, callback _Function_, context _Mixed_) Add a new event listener. #### Arguments - **type** _String_ event type, click, dbclick, keydown etc. - **selectors** _String_ CSS3 selector that matches the element - **callback** _Function_ - **context** _Mixed_ --------------------------------------- ### Events.remove(type _String_, selectors _String_, callback _Function_) Remove the listeners again. #### Arguments - **type** _String_ event type, click, dbclick, keydown etc. - **selectors** _String_ CSS3 selector that matches the element - **callback** _Function_ --------------------------------------- ### Cortex.push(name _String_, library _Mixed_) Cortex.push() allows us to load library files comply async, if Cortex does not yet exist in the global scope it would be set to an array where the functions will be pushed. So when this "main" library is loaded in, it will search for all old Cortex instances and execute it. #### Arguments - **name** _String_ the name of the library - **library** _Mixed_ either a string or a function. ---------------------------------------: ### $ = Cortex.find(selector _String_, context _DOM_) Simple CSS3 selector engine targeted for the high-end browsers. By using our own interface it's relatively easy to hook in optional support for different browsers. #### Arguments - **selector** _String_ - **context** _DOM_ optional context --------------------------------------- ### Cortex.active(fn _Function_) Application framework bootstrapper. It scans the current document for cerebral/cortex script types and parses them as JSON which will be used as application configuration. #### Arguments - **fn** _Function_ the callback for when the cortex has become active --------------------------------------- ### Cortex.app(name _String_, instance _Function_, options _Object_) Create a new Cortex application once everything is loaded correctly. Options can be provided with an optional `once` key. This will defer app initialization until the listener is trigger. Without a `once` key the app will initialize immediatly. #### Arguments - **name** _String_ name of the application - **instance** _Function_ constructor of the application - **options** _Object_ optional options for the app. #### Example ``` Cortex.app('Progress', Cortex.View.extend({}), { once: 'start' }); ```