| New file |
|---|
| 0,0 → 1,252 |
|---|
| if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo._base.lang"] = true; |
| dojo.provide("dojo._base.lang"); |
| |
| // Crockford (ish) functions |
| |
| dojo.isString = function(/*anything*/ it){ |
| // summary: Return true if it is a String |
| return typeof it == "string" || it instanceof String; // Boolean |
| } |
| |
| dojo.isArray = function(/*anything*/ it){ |
| // summary: Return true if it is an Array |
| return it && it instanceof Array || typeof it == "array"; // Boolean |
| } |
| |
| /*===== |
| dojo.isFunction = function(it){ |
| // summary: Return true if it is a Function |
| // it: anything |
| } |
| =====*/ |
| |
| dojo.isFunction = (function(){ |
| var _isFunction = function(/*anything*/ it){ |
| return typeof it == "function" || it instanceof Function; // Boolean |
| }; |
| |
| return dojo.isSafari ? |
| // only slow this down w/ gratuitious casting in Safari since it's what's b0rken |
| function(/*anything*/ it){ |
| if(typeof it == "function" && it == "[object NodeList]"){ return false; } |
| return _isFunction(it); // Boolean |
| } : _isFunction; |
| })(); |
| |
| dojo.isObject = function(/*anything*/ it){ |
| // summary: |
| // Returns true if it is a JavaScript object (or an Array, a Function or null) |
| return it !== undefined && |
| (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean |
| } |
| |
| dojo.isArrayLike = function(/*anything*/ it){ |
| // summary: |
| // similar to dojo.isArray() but more permissive |
| // description: |
| // Doesn't strongly test for "arrayness". Instead, settles for "isn't |
| // a string or number and has a length property". Arguments objects |
| // and DOM collections will return true when passed to |
| // dojo.isArrayLike(), but will return false when passed to |
| // dojo.isArray(). |
| // return: |
| // If it walks like a duck and quicks like a duck, return true |
| var d = dojo; |
| return it && it !== undefined && |
| // keep out built-in constructors (Number, String, ...) which have length |
| // properties |
| !d.isString(it) && !d.isFunction(it) && |
| !(it.tagName && it.tagName.toLowerCase() == 'form') && |
| (d.isArray(it) || isFinite(it.length)); // Boolean |
| } |
| |
| dojo.isAlien = function(/*anything*/ it){ |
| // summary: |
| // Returns true if it is a built-in function or some other kind of |
| // oddball that *should* report as a function but doesn't |
| return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean |
| } |
| |
| dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){ |
| // summary: |
| // Adds all properties and methods of props to constructor's |
| // prototype, making them available to all instances created with |
| // constructor. |
| for(var i=1, l=arguments.length; i<l; i++){ |
| dojo._mixin(constructor.prototype, arguments[i]); |
| } |
| return constructor; // Object |
| } |
| |
| dojo._hitchArgs = function(scope, method /*,...*/){ |
| var pre = dojo._toArray(arguments, 2); |
| var named = dojo.isString(method); |
| return function(){ |
| // arrayify arguments |
| var args = dojo._toArray(arguments); |
| // locate our method |
| var f = named ? (scope||dojo.global)[method] : method; |
| // invoke with collected args |
| return f && f.apply(scope || this, pre.concat(args)); // mixed |
| } // Function |
| } |
| |
| dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/){ |
| // summary: |
| // Returns a function that will only ever execute in the a given scope. |
| // This allows for easy use of object member functions |
| // in callbacks and other places in which the "this" keyword may |
| // otherwise not reference the expected scope. |
| // Any number of default positional arguments may be passed as parameters |
| // beyond "method". |
| // Each of these values will be used to "placehold" (similar to curry) |
| // for the hitched function. |
| // scope: |
| // The scope to use when method executes. If method is a string, |
| // scope is also the object containing method. |
| // method: |
| // A function to be hitched to scope, or the name of the method in |
| // scope to be hitched. |
| // example: |
| // | dojo.hitch(foo, "bar")(); |
| // runs foo.bar() in the scope of foo |
| // example: |
| // | dojo.hitch(foo, myFunction); |
| // returns a function that runs myFunction in the scope of foo |
| if(arguments.length > 2){ |
| return dojo._hitchArgs.apply(dojo, arguments); // Function |
| } |
| if(!method){ |
| method = scope; |
| scope = null; |
| } |
| if(dojo.isString(method)){ |
| scope = scope || dojo.global; |
| if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); } |
| return function(){ return scope[method].apply(scope, arguments || []); }; // Function |
| } |
| return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function |
| } |
| |
| /*===== |
| dojo.delegate = function(obj, props){ |
| // summary: |
| // returns a new object which "looks" to obj for properties which it |
| // does not have a value for. Optionally takes a bag of properties to |
| // seed the returned object with initially. |
| // description: |
| // This is a small implementaton of the Boodman/Crockford delegation |
| // pattern in JavaScript. An intermediate object constructor mediates |
| // the prototype chain for the returned object, using it to delegate |
| // down to obj for property lookup when object-local lookup fails. |
| // This can be thought of similarly to ES4's "wrap", save that it does |
| // not act on types but rather on pure objects. |
| // obj: |
| // The object to delegate to for properties not found directly on the |
| // return object or in props. |
| // props: |
| // an object containing properties to assign to the returned object |
| // returns: |
| // an Object of anonymous type |
| // example: |
| // | var foo = { bar: "baz" }; |
| // | var thinger = dojo.delegate(foo, { thud: "xyzzy"}); |
| // | thinger.bar == "baz"; // delegated to foo |
| // | foo.xyzzy == undefined; // by definition |
| // | thinger.xyzzy == "xyzzy"; // mixed in from props |
| // | foo.bar = "thonk"; |
| // | thinger.bar == "thonk"; // still delegated to foo's bar |
| } |
| =====*/ |
| |
| |
| dojo.delegate = dojo._delegate = function(obj, props){ |
| |
| // boodman/crockford delegation |
| function TMP(){}; |
| TMP.prototype = obj; |
| var tmp = new TMP(); |
| if(props){ |
| dojo.mixin(tmp, props); |
| } |
| return tmp; // Object |
| } |
| |
| dojo.partial = function(/*Function|String*/method /*, ...*/){ |
| // summary: |
| // similar to hitch() except that the scope object is left to be |
| // whatever the execution context eventually becomes. |
| // description: |
| // Calling dojo.partial is the functional equivalent of calling: |
| // | dojo.hitch(null, funcName, ...); |
| var arr = [ null ]; |
| return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function |
| } |
| |
| dojo._toArray = function(/*Object*/obj, /*Number?*/offset, /*Array?*/ startWith){ |
| // summary: |
| // Converts an array-like object (i.e. arguments, DOMCollection) |
| // to an array. Returns a new Array object. |
| // obj: |
| // the object to "arrayify". We expect the object to have, at a |
| // minimum, a length property which corresponds to integer-indexed |
| // properties. |
| // offset: |
| // the location in obj to start iterating from. Defaults to 0. Optional. |
| // startWith: |
| // An array to pack with the properties of obj. If provided, |
| // properties in obj are appended at the end of startWith and |
| // startWith is the returned array. |
| var arr = startWith||[]; |
| for(var x = offset || 0; x < obj.length; x++){ |
| arr.push(obj[x]); |
| } |
| return arr; // Array |
| } |
| |
| dojo.clone = function(/*anything*/ o){ |
| // summary: |
| // Clones objects (including DOM nodes) and all children. |
| // Warning: do not clone cyclic structures. |
| if(!o){ return o; } |
| if(dojo.isArray(o)){ |
| var r = []; |
| for(var i = 0; i < o.length; ++i){ |
| r.push(dojo.clone(o[i])); |
| } |
| return r; // Array |
| } |
| if(!dojo.isObject(o)){ |
| return o; /*anything*/ |
| } |
| if(o.nodeType && o.cloneNode){ // isNode |
| return o.cloneNode(true); // Node |
| } |
| if(o instanceof Date){ |
| return new Date(o.getTime()); // Date |
| } |
| // Generic objects |
| var r = new o.constructor(); // specific to dojo.declare()'d classes! |
| for(var i in o){ |
| if(!(i in r) || r[i] != o[i]){ |
| r[i] = dojo.clone(o[i]); |
| } |
| } |
| return r; // Object |
| } |
| |
| dojo.trim = function(/*String*/ str){ |
| // summary: |
| // trims whitespaces from both sides of the string |
| // description: |
| // This version of trim() was selected for inclusion into the base due |
| // to its compact size and relatively good performance (see Steven |
| // Levithan's blog: |
| // http://blog.stevenlevithan.com/archives/faster-trim-javascript). |
| // The fastest but longest version of this function is located at |
| // dojo.string.trim() |
| return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String |
| } |
| |
| } |