From f0cfe83e3725f9a3928da97a6e3085e79cb25309 Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Mon, 18 Mar 2013 10:26:24 +0400 Subject: upgrade dojo to 1.8.3 (refs #570) --- lib/dojo/_base/array.js.uncompressed.js | 343 ++++++++++++++++++++++++++++++++ 1 file changed, 343 insertions(+) create mode 100644 lib/dojo/_base/array.js.uncompressed.js (limited to 'lib/dojo/_base/array.js.uncompressed.js') diff --git a/lib/dojo/_base/array.js.uncompressed.js b/lib/dojo/_base/array.js.uncompressed.js new file mode 100644 index 000000000..eb8b7c391 --- /dev/null +++ b/lib/dojo/_base/array.js.uncompressed.js @@ -0,0 +1,343 @@ +define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ + // module: + // dojo/_base/array + + // our old simple function builder stuff + var cache = {}, u; + + function buildFn(fn){ + return cache[fn] = new Function("item", "index", "array", fn); // Function + } + // magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + + // every & some + + function everyOrSome(some){ + var every = !some; + return function(a, fn, o){ + var i = 0, l = a && a.length || 0, result; + if(l && typeof a == "string") a = a.split(""); + if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + if(o){ + for(; i < l; ++i){ + result = !fn.call(o, a[i], i, a); + if(some ^ result){ + return !result; + } + } + }else{ + for(; i < l; ++i){ + result = !fn(a[i], i, a); + if(some ^ result){ + return !result; + } + } + } + return every; // Boolean + }; + } + + // indexOf, lastIndexOf + + function index(up){ + var delta = 1, lOver = 0, uOver = 0; + if(!up){ + delta = lOver = uOver = -1; + } + return function(a, x, from, last){ + if(last && delta > 0){ + // TODO: why do we use a non-standard signature? why do we need "last"? + return array.lastIndexOf(a, x, from); + } + var l = a && a.length || 0, end = up ? l + uOver : lOver, i; + if(from === u){ + i = up ? lOver : l + uOver; + }else{ + if(from < 0){ + i = l + from; + if(i < 0){ + i = lOver; + } + }else{ + i = from >= l ? l + uOver : from; + } + } + if(l && typeof a == "string") a = a.split(""); + for(; i != end; i += delta){ + if(a[i] == x){ + return i; // Number + } + } + return -1; // Number + }; + } + + var array = { + // summary: + // The Javascript v1.6 array extensions. + + every: everyOrSome(false), + /*===== + every: function(arr, callback, thisObject){ + // summary: + // Determines whether or not every item in arr satisfies the + // condition implemented by callback. + // arr: Array|String + // the array to iterate on. If a string, operates on individual characters. + // callback: Function|String + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: Object? + // may be used to scope the call to callback + // returns: Boolean + // description: + // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every + // example: + // | // returns false + // | array.every([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // returns true + // | array.every([1, 2, 3, 4], function(item){ return item>0; }); + }, + =====*/ + + some: everyOrSome(true), + /*===== + some: function(arr, callback, thisObject){ + // summary: + // Determines whether or not any item in arr satisfies the + // condition implemented by callback. + // arr: Array|String + // the array to iterate over. If a string, operates on individual characters. + // callback: Function|String + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: Object? + // may be used to scope the call to callback + // returns: Boolean + // description: + // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some + // example: + // | // is true + // | array.some([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // is false + // | array.some([1, 2, 3, 4], function(item){ return item<1; }); + }, + =====*/ + + indexOf: index(true), + /*===== + indexOf: function(arr, value, fromIndex, findLast){ + // summary: + // locates the first index of the provided value in the + // passed array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's indexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf + // arr: Array + // value: Object + // fromIndex: Integer? + // findLast: Boolean? + // returns: Number + }, + =====*/ + + lastIndexOf: index(false), + /*===== + lastIndexOf: function(arr, value, fromIndex){ + // summary: + // locates the last index of the provided value in the passed + // array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's lastIndexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf + // arr: Array, + // value: Object, + // fromIndex: Integer? + // returns: Number + }, + =====*/ + + forEach: function(arr, callback, thisObject){ + // summary: + // for every item in arr, callback is invoked. Return values are ignored. + // If you want to break out of the loop, consider using array.every() or array.some(). + // forEach does not allow breaking out of the loop over the items in arr. + // arr: + // the array to iterate over. If a string, operates on individual characters. + // callback: + // a function is invoked with three arguments: item, index, and array + // thisObject: + // may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach + // example: + // | // log out all members of the array: + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item){ + // | console.log(item); + // | } + // | ); + // example: + // | // log out the members and their indexes + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item, idx, arr){ + // | console.log(item, "at index:", idx); + // | } + // | ); + // example: + // | // use a scoped object member as the callback + // | + // | var obj = { + // | prefix: "logged via obj.callback:", + // | callback: function(item){ + // | console.log(this.prefix, item); + // | } + // | }; + // | + // | // specifying the scope function executes the callback in that scope + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | obj.callback, + // | obj + // | ); + // | + // | // alternately, we can accomplish the same thing with lang.hitch() + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | lang.hitch(obj, "callback") + // | ); + // arr: Array|String + // callback: Function|String + // thisObject: Object? + + var i = 0, l = arr && arr.length || 0; + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + callback.call(thisObject, arr[i], i, arr); + } + }else{ + for(; i < l; ++i){ + callback(arr[i], i, arr); + } + } + }, + + map: function(arr, callback, thisObject, Ctr){ + // summary: + // applies callback to each element of arr and returns + // an Array with the results + // arr: Array|String + // the array to iterate on. If a string, operates on + // individual characters. + // callback: Function|String + // a function is invoked with three arguments, (item, index, + // array), and returns a value + // thisObject: Object? + // may be used to scope the call to callback + // returns: Array + // description: + // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map + // example: + // | // returns [2, 3, 4, 5] + // | array.map([1, 2, 3, 4], function(item){ return item+1 }); + + // TODO: why do we have a non-standard signature here? do we need "Ctr"? + var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l); + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + out[i] = callback.call(thisObject, arr[i], i, arr); + } + }else{ + for(; i < l; ++i){ + out[i] = callback(arr[i], i, arr); + } + } + return out; // Array + }, + + filter: function(arr, callback, thisObject){ + // summary: + // Returns a new Array with those items from arr that match the + // condition implemented by callback. + // arr: Array + // the array to iterate over. + // callback: Function|String + // a function that is invoked with three arguments (item, + // index, array). The return of this function is expected to + // be a boolean which determines whether the passed-in item + // will be included in the returned array. + // thisObject: Object? + // may be used to scope the call to callback + // returns: Array + // description: + // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter + // example: + // | // returns [2, 3, 4] + // | array.filter([1, 2, 3, 4], function(item){ return item>1; }); + + // TODO: do we need "Ctr" here like in map()? + var i = 0, l = arr && arr.length || 0, out = [], value; + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + value = arr[i]; + if(callback.call(thisObject, value, i, arr)){ + out.push(value); + } + } + }else{ + for(; i < l; ++i){ + value = arr[i]; + if(callback(value, i, arr)){ + out.push(value); + } + } + } + return out; // Array + }, + + clearCache: function(){ + cache = {}; + } + }; + + + 1 && lang.mixin(dojo, array); + + return array; +}); -- cgit v1.2.3