393 lines
13 KiB
JavaScript
393 lines
13 KiB
JavaScript
/*
|
|
Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
|
|
Available via Academic Free License >= 2.1 OR the modified BSD license.
|
|
see: http://dojotoolkit.org/license for details
|
|
*/
|
|
|
|
|
|
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");
|
|
|
|
(function(){
|
|
var d = dojo, opts = Object.prototype.toString;
|
|
|
|
// 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.
|
|
// Does not work on Arrays created in other windows.
|
|
return it && (it instanceof Array || typeof it == "array"); // Boolean
|
|
}
|
|
|
|
dojo.isFunction = function(/*anything*/ it){
|
|
// summary:
|
|
// Return true if it is a Function
|
|
return opts.call(it) === "[object Function]";
|
|
};
|
|
|
|
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" || d.isArray(it) || d.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().
|
|
// returns:
|
|
// If it walks like a duck and quacks like a duck, return `true`
|
|
return it && it !== undefined && // Boolean
|
|
// 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));
|
|
}
|
|
|
|
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 && !d.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++){
|
|
d._mixin(constructor.prototype, arguments[i]);
|
|
}
|
|
return constructor; // Object
|
|
}
|
|
|
|
dojo._hitchArgs = function(scope, method /*,...*/){
|
|
var pre = d._toArray(arguments, 2);
|
|
var named = d.isString(method);
|
|
return function(){
|
|
// arrayify arguments
|
|
var args = d._toArray(arguments);
|
|
// locate our method
|
|
var f = named ? (scope||d.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
|
|
// example:
|
|
// Expansion on the default positional arguments passed along from
|
|
// hitch. Passed args are mixed first, additional args after.
|
|
// | var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
|
|
// | var fn = dojo.hitch(foo, "bar", 1, 2);
|
|
// | fn(3); // logs "1, 2, 3"
|
|
// example:
|
|
// | var foo = { bar: 2 };
|
|
// | dojo.hitch(foo, function(){ this.bar = 10; })();
|
|
// execute an anonymous function in scope of foo
|
|
|
|
if(arguments.length > 2){
|
|
return d._hitchArgs.apply(d, arguments); // Function
|
|
}
|
|
if(!method){
|
|
method = scope;
|
|
scope = null;
|
|
}
|
|
if(d.isString(method)){
|
|
scope = scope || d.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.thud == undefined; // by definition
|
|
// | thinger.thud == "xyzzy"; // mixed in from props
|
|
// | foo.bar = "thonk";
|
|
// | thinger.bar == "thonk"; // still delegated to foo's bar
|
|
}
|
|
=====*/
|
|
|
|
dojo.delegate = dojo._delegate = (function(){
|
|
// boodman/crockford delegation w/ cornford optimization
|
|
function TMP(){}
|
|
return function(obj, props){
|
|
TMP.prototype = obj;
|
|
var tmp = new TMP();
|
|
TMP.prototype = null;
|
|
if(props){
|
|
d._mixin(tmp, props);
|
|
}
|
|
return tmp; // Object
|
|
}
|
|
})();
|
|
|
|
/*=====
|
|
dojo._toArray = function(obj, offset, startWith){
|
|
// summary:
|
|
// Converts an array-like object (i.e. arguments, DOMCollection) to an
|
|
// array. Returns a new Array with the elements of obj.
|
|
// obj: Object
|
|
// the object to "arrayify". We expect the object to have, at a
|
|
// minimum, a length property which corresponds to integer-indexed
|
|
// properties.
|
|
// offset: Number?
|
|
// the location in obj to start iterating from. Defaults to 0.
|
|
// Optional.
|
|
// startWith: Array?
|
|
// 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 efficient = function(obj, offset, startWith){
|
|
return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
|
|
};
|
|
|
|
var slow = function(obj, offset, startWith){
|
|
var arr = startWith||[];
|
|
for(var x = offset || 0; x < obj.length; x++){
|
|
arr.push(obj[x]);
|
|
}
|
|
return arr;
|
|
};
|
|
|
|
dojo._toArray =
|
|
d.isIE ? function(obj){
|
|
return ((obj.item) ? slow : efficient).apply(this, arguments);
|
|
} :
|
|
efficient;
|
|
|
|
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 d.hitch.apply(d, arr.concat(d._toArray(arguments))); // Function
|
|
}
|
|
|
|
var extraNames = d._extraNames, extraLen = extraNames.length, empty = {};
|
|
|
|
dojo.clone = function(/*anything*/ o){
|
|
// summary:
|
|
// Clones objects (including DOM nodes) and all children.
|
|
// Warning: do not clone cyclic structures.
|
|
if(!o || typeof o != "object" || d.isFunction(o)){
|
|
// null, undefined, any non-object, or function
|
|
return o; // anything
|
|
}
|
|
if(o.nodeType && "cloneNode" in o){
|
|
// DOM Node
|
|
return o.cloneNode(true); // Node
|
|
}
|
|
if(o instanceof Date){
|
|
// Date
|
|
return new Date(o.getTime()); // Date
|
|
}
|
|
var r, i, l, s, name;
|
|
if(d.isArray(o)){
|
|
// array
|
|
r = [];
|
|
for(i = 0, l = o.length; i < l; ++i){
|
|
if(i in o){
|
|
r.push(d.clone(o[i]));
|
|
}
|
|
}
|
|
// we don't clone functions for performance reasons
|
|
// }else if(d.isFunction(o)){
|
|
// // function
|
|
// r = function(){ return o.apply(this, arguments); };
|
|
}else{
|
|
// generic objects
|
|
r = o.constructor ? new o.constructor() : {};
|
|
}
|
|
for(name in o){
|
|
// the "tobj" condition avoid copying properties in "source"
|
|
// inherited from Object.prototype. For example, if target has a custom
|
|
// toString() method, don't overwrite it with the toString() method
|
|
// that source inherited from Object.prototype
|
|
s = o[name];
|
|
if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){
|
|
r[name] = d.clone(s);
|
|
}
|
|
}
|
|
// IE doesn't recognize some custom functions in for..in
|
|
if(extraLen){
|
|
for(i = 0; i < extraLen; ++i){
|
|
name = extraNames[i];
|
|
s = o[name];
|
|
if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){
|
|
r[name] = s; // functions only, we don't clone them
|
|
}
|
|
}
|
|
}
|
|
return r; // Object
|
|
}
|
|
|
|
/*=====
|
|
dojo.trim = function(str){
|
|
// summary:
|
|
// Trims whitespace from both sides of the string
|
|
// str: String
|
|
// String to be trimmed
|
|
// returns: String
|
|
// Returns the trimmed 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)
|
|
// Uses String.prototype.trim instead, if available.
|
|
// The fastest but longest version of this function is located at
|
|
// dojo.string.trim()
|
|
return ""; // String
|
|
}
|
|
=====*/
|
|
|
|
dojo.trim = String.prototype.trim ?
|
|
function(str){ return str.trim(); } :
|
|
function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); };
|
|
|
|
/*=====
|
|
dojo.replace = function(tmpl, map, pattern){
|
|
// summary:
|
|
// Performs parameterized substitutions on a string. Throws an
|
|
// exception if any parameter is unmatched.
|
|
// tmpl: String
|
|
// String to be used as a template.
|
|
// map: Object|Function
|
|
// If an object, it is used as a dictionary to look up substitutions.
|
|
// If a function, it is called for every substitution with following
|
|
// parameters: a whole match, a name, an offset, and the whole template
|
|
// string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
|
|
// for more details).
|
|
// pattern: RegEx?
|
|
// Optional regular expression objects that overrides the default pattern.
|
|
// Must be global and match one item. The default is: /\{([^\}]+)\}/g,
|
|
// which matches patterns like that: "{xxx}", where "xxx" is any sequence
|
|
// of characters, which doesn't include "}".
|
|
// returns: String
|
|
// Returns the substituted string.
|
|
// example:
|
|
// | // uses a dictionary for substitutions:
|
|
// | dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
|
|
// | {
|
|
// | nick: "Bob",
|
|
// | name: {
|
|
// | first: "Robert",
|
|
// | middle: "X",
|
|
// | last: "Cringely"
|
|
// | }
|
|
// | });
|
|
// | // returns: Hello, Robert Cringely AKA Bob!
|
|
// example:
|
|
// | // uses an array for substitutions:
|
|
// | dojo.replace("Hello, {0} {2}!",
|
|
// | ["Robert", "X", "Cringely"]);
|
|
// | // returns: Hello, Robert Cringely!
|
|
// example:
|
|
// | // uses a function for substitutions:
|
|
// | function sum(a){
|
|
// | var t = 0;
|
|
// | dojo.forEach(a, function(x){ t += x; });
|
|
// | return t;
|
|
// | }
|
|
// | dojo.replace(
|
|
// | "{count} payments averaging {avg} USD per payment.",
|
|
// | dojo.hitch(
|
|
// | { payments: [11, 16, 12] },
|
|
// | function(_, key){
|
|
// | switch(key){
|
|
// | case "count": return this.payments.length;
|
|
// | case "min": return Math.min.apply(Math, this.payments);
|
|
// | case "max": return Math.max.apply(Math, this.payments);
|
|
// | case "sum": return sum(this.payments);
|
|
// | case "avg": return sum(this.payments) / this.payments.length;
|
|
// | }
|
|
// | }
|
|
// | )
|
|
// | );
|
|
// | // prints: 3 payments averaging 13 USD per payment.
|
|
// example:
|
|
// | // uses an alternative PHP-like pattern for substitutions:
|
|
// | dojo.replace("Hello, ${0} ${2}!",
|
|
// | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
|
|
// | // returns: Hello, Robert Cringely!
|
|
return ""; // String
|
|
}
|
|
=====*/
|
|
|
|
var _pattern = /\{([^\}]+)\}/g;
|
|
dojo.replace = function(tmpl, map, pattern){
|
|
return tmpl.replace(pattern || _pattern, d.isFunction(map) ?
|
|
map : function(_, k){ return d.getObject(k, false, map); });
|
|
};
|
|
})();
|
|
|
|
}
|