diff options
Diffstat (limited to 'lib/dojo/NodeList-data.js.uncompressed.js')
| -rw-r--r-- | lib/dojo/NodeList-data.js.uncompressed.js | 192 |
1 files changed, 192 insertions, 0 deletions
diff --git a/lib/dojo/NodeList-data.js.uncompressed.js b/lib/dojo/NodeList-data.js.uncompressed.js new file mode 100644 index 000000000..6b6edf1e7 --- /dev/null +++ b/lib/dojo/NodeList-data.js.uncompressed.js @@ -0,0 +1,192 @@ +define("dojo/NodeList-data", [ + "./_base/kernel", "./query", "./_base/lang", "./_base/array", "./dom-attr" +], function(dojo, query, lang, array, attr){ + + // module: + // dojo/NodeList-data + + /*===== + return function(){ + // summary: + // Adds data() and removeData() methods to NodeList, and returns NodeList constructor. + }; + =====*/ + + var NodeList = query.NodeList; + + var dataCache = {}, x = 0, dataattr = "data-dojo-dataid", + dopid = function(node){ + // summary: + // Return a uniqueish ID for the passed node reference + var pid = attr.get(node, dataattr); + if(!pid){ + pid = "pid" + (x++); + attr.set(node, dataattr, pid); + } + return pid; + } + ; + + + var dodata = dojo._nodeData = function(node, key, value){ + // summary: + // Private helper for dojo/NodeList.data for single node data access. Refer to NodeList.data + // documentation for more information. + // + // node: String|DomNode + // The node to associate data with + // + // key: Object|String? + // If an object, act as a setter and iterate over said object setting data items as defined. + // If a string, and `value` present, set the data for defined `key` to `value` + // If a string, and `value` absent, act as a getter, returning the data associated with said `key` + // + // value: Anything? + // The value to set for said `key`, provided `key` is a string (and not an object) + // + var pid = dopid(node), r; + if(!dataCache[pid]){ dataCache[pid] = {}; } + + // API discrepency: calling with only a node returns the whole object. $.data throws + if(arguments.length == 1){ r = dataCache[pid]; } + if(typeof key == "string"){ + // either getter or setter, based on `value` presence + if(arguments.length > 2){ + dataCache[pid][key] = value; + }else{ + r = dataCache[pid][key]; + } + }else{ + // must be a setter, mix `value` into data hash + // API discrepency: using object as setter works here + r = lang.mixin(dataCache[pid], key); + } + + return r; // Object|Anything|Nothing + }; + + var removeData = dojo._removeNodeData = function(node, key){ + // summary: + // Remove some data from this node + // node: String|DomNode + // The node reference to remove data from + // key: String? + // If omitted, remove all data in this dataset. + // If passed, remove only the passed `key` in the associated dataset + var pid = dopid(node); + if(dataCache[pid]){ + if(key){ + delete dataCache[pid][key]; + }else{ + delete dataCache[pid]; + } + } + }; + + dojo._gcNodeData = function(){ + // summary: + // super expensive: GC all data in the data for nodes that no longer exist in the dom. + // description: + // super expensive: GC all data in the data for nodes that no longer exist in the dom. + // MUCH safer to do this yourself, manually, on a per-node basis (via `NodeList.removeData()`) + // provided as a stop-gap for exceptionally large/complex applications with constantly changing + // content regions (eg: a dijit/layout/ContentPane with replacing data) + // There is NO automatic GC going on. If you dojo.destroy() a node, you should _removeNodeData + // prior to destruction. + var livePids = query("[" + dataattr + "]").map(dopid); + for(var i in dataCache){ + if(array.indexOf(livePids, i) < 0){ delete dataCache[i]; } + } + }; + + // make nodeData and removeNodeData public on dojo/NodeList: + lang.extend(NodeList, { + data: NodeList._adaptWithCondition(dodata, function(a){ + return a.length === 0 || a.length == 1 && (typeof a[0] == "string"); + }), + removeData: NodeList._adaptAsForEach(removeData) + }); + + /*===== + lang.extend(NodeList, { + data: function(key, value){ + // summary: + // stash or get some arbitrary data on/from these nodes. + // + // description: + // Stash or get some arbitrary data on/from these nodes. This private _data function is + // exposed publicly on `dojo/NodeList`, eg: as the result of a `dojo.query` call. + // DIFFERS from jQuery.data in that when used as a getter, the entire list is ALWAYS + // returned. EVEN WHEN THE LIST IS length == 1. + // + // A single-node version of this function is provided as `dojo._nodeData`, which follows + // the same signature, though expects a String ID or DomNode reference in the first + // position, before key/value arguments. + // + // node: String|DomNode + // The node to associate data with + // + // key: Object|String? + // If an object, act as a setter and iterate over said object setting data items as defined. + // If a string, and `value` present, set the data for defined `key` to `value` + // If a string, and `value` absent, act as a getter, returning the data associated with said `key` + // + // value: Anything? + // The value to set for said `key`, provided `key` is a string (and not an object) + // + // example: + // Set a key `bar` to some data, then retrieve it. + // | dojo.query(".foo").data("bar", "touched"); + // | var touched = dojo.query(".foo").data("bar"); + // | if(touched[0] == "touched"){ alert('win'); } + // + // example: + // Get all the data items for a given node. + // | var list = dojo.query(".foo").data(); + // | var first = list[0]; + // + // example: + // Set the data to a complex hash. Overwrites existing keys with new value + // | dojo.query(".foo").data({ bar:"baz", foo:"bar" }); + // Then get some random key: + // | dojo.query(".foo").data("foo"); // returns [`bar`] + // + // returns: Object|Anything|Nothing + // When used as a setter via `dojo/NodeList`, a NodeList instance is returned + // for further chaining. When used as a getter via `dojo/NodeList` an ARRAY + // of items is returned. The items in the array correspond to the elements + // in the original list. This is true even when the list length is 1, eg: + // when looking up a node by ID (#foo) + }, + + removeData: function(key){ + // summary: + // Remove the data associated with these nodes. + // key: String? + // If omitted, clean all data for this node. + // If passed, remove the data item found at `key` + } + }); + =====*/ + +// TODO: this is the basic implementation of adaptWithCondtionAndWhenMappedConsiderLength, for lack of a better API name +// it conflicts with the the `dojo/NodeList` way: always always return an arrayLike thinger. Consider for 2.0: +// +// NodeList.prototype.data = function(key, value){ +// var a = arguments, r; +// if(a.length === 0 || a.length == 1 && (typeof a[0] == "string")){ +// r = this.map(function(node){ +// return d._data(node, key); +// }); +// if(r.length == 1){ r = r[0]; } // the offending line, and the diff on adaptWithCondition +// }else{ +// r = this.forEach(function(node){ +// d._data(node, key, value); +// }); +// } +// return r; // NodeList|Array|SingleItem +// }; + + return NodeList; + +}); |