diff options
author | Andrew Dolgov <[email protected]> | 2012-08-14 18:59:10 +0400 |
---|---|---|
committer | Andrew Dolgov <[email protected]> | 2012-08-14 18:59:18 +0400 |
commit | 1354d17270961fff662d40f90521223f8fd0d73b (patch) | |
tree | e9266be71587e47c800303446e968a6d3565e2cf /lib/dojo/NodeList-data.js.uncompressed.js | |
parent | d04f8c826f5283765f52cf6b98b42a1ed8f2d6bc (diff) |
update dojo to 1.7.3
Diffstat (limited to 'lib/dojo/NodeList-data.js.uncompressed.js')
-rw-r--r-- | lib/dojo/NodeList-data.js.uncompressed.js | 181 |
1 files changed, 181 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..b8c76b0b0 --- /dev/null +++ b/lib/dojo/NodeList-data.js.uncompressed.js @@ -0,0 +1,181 @@ +define("dojo/NodeList-data", [ + "./_base/kernel", "./query", "./_base/lang", "./_base/array", "./dom-attr" +], function(dojo, query, lang, array, attr) { + // module: + // dojo/NodeList-data + // summary: + // TODOC + +var NodeList = query.NodeList; +/*===== +// doc alias helpers: +var NodeList = dojo.NodeList; + + dojo.NodeList.prototype.data = function(key, value){ + // summary: stash or get some arbitrary data on/from these nodes. + // + // description: + // Stash or get some arbirtrary 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 chaning. 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) + }; + + dojo.NodeList.prototype.removeData = function(key){ + // summary: Remove the data associated with these nodes. + // key: String? + // If ommitted, clean all data for this node. + // If passed, remove the data item found at `key` + }; + +=====*/ + + 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) + }); + +// TODO: this is the basic implemetation 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; // dojo.NodeList|Array|SingleItem +// }; + + return NodeList; + +}); |