Makes a deep copy of the object that's passed as its sole argument and returns the copied object. Every copied object and array property of the original object will be separate and distinct from the original object. In other words, after the deep copy occurs, any new expando property added to either object won't be replicated to the other.
*/
//
deepCopy: function (vOrig) {
var o,
i,
len;
if (vOrig instanceof Array) { //arrays are handled differently than objects;
o = [];
for (i = 0, len = vOrig.length; i < len; i++) {
v = vOrig[i];
if (v instanceof Object) { //could be an array or an object;
o.push(arguments.callee(v));
} else {
o.push(v);
}
}
} else {
o = {};
for (var prop in vOrig) {
if (vOrig.hasOwnProperty(prop)) {
v = vOrig[prop];
if (v instanceof Object) { //could be an array or an object;
o[prop] = arguments.callee(v);
} else {
o[prop] = v;
}
}
}
}
return o;
},
//
/**
* @function JSLITE.extend
* @param {Function} subClass
* @param {Mixed} superClass Pass either a constructor or an object
* @param {Object} overrides optional Any object properties will be added to the subclass' prototype
* @return {Function} subClass
* @describe
Extends one class with another class. Returns the subClass constructor.
This method causes one reference type to inherit from another using the prototype chaining inheritance pattern. Note that this does not inherit the superClass' instance properties, it only inherits properties residing on the superClass' prototype object. Use combination inheritance (i.e., prototype chaining + constructor stealing) to inherit all of the properties from superClass (constructor stealing, aka object masquerading or classical inheritance, will inherit the instance properties).
It's also possible to create a constructor by passing the reference type to extend as the first argument and the methods to override as the second argument.
For prototypal inheritance please see JSLITE.proto.
* @example
function Person() {
Person.superclass.constructor.call(); //constructor stealing;
}
JSLITE.extend(Person, JSLITE.Observer); //prototype chaining;
-- or --
Car = JSLITE.extend(JSLITE.Observer, {
init: function () {
//code here...;
}
});
*/
//
extend: function (subClass, superClass, overrides) {
if (superClass.constructor === Object) {
overrides = superClass;
superClass = subClass;
subClass = overrides.constructor !== Object ? overrides.constructor : function () { superClass.apply(this, arguments); };
}
var F = function () {};
F.prototype = superClass.prototype;
subClass.prototype = new F();
subClass.superclass = superClass.prototype;
subClass.prototype.constructor = subClass;
JSLITE.apply(subClass.prototype, overrides);
subClass.override = function (o) { //class method;
JSLITE.apply(subClass, o);
};
return subClass;
},
//
/*****************************************************************************************************************/
/*****************************************************************************************************************/
/**
* @function JSLITE.flush
* @param {Array/String} vAction Function argument(s) can be an Array or one or more Strings
* @return {None}
* @describe
null, undefined and NaN are considered to be empty values.
*/
//
isEmpty: function (v) {
var bEmpty = true,
prop;
if (typeof v === "string" && v.length > 0 || typeof v === "number" && !isNaN(v) || v instanceof Array && v.length > 0 || v instanceof Date) {
bEmpty = false;
} else if (v instanceof Object) {
for (prop in v) {
if (v.hasOwnProperty(prop)) {
bEmpty = false;
break;
}
}
}
/*
//jsLint suggested changing SWITCH to an IF;
switch (true) { //undefined, null and NaN values aren't represented;
case typeof v === "string" && v.length > 0:
case typeof v === "number" && !isNaN(v): //remember typeof NaN === "number";
case v instanceof Array && v.length > 0:
case v instanceof Date:
bEmpty = false;
break;
case v instanceof Object:
for (var prop in v) {
if (v.hasOwnProperty(prop)) {
bEmpty = false;
break;
}
}
}
*/
return bEmpty;
},
//
/**
* @function JSLITE.makeArray
* @param {Object} o
* @return {Array}
* @describe
Converts a collection of nodes or the arguments object into a true array.
A tip of the hat to the Prototype library.
Note: Nicholas Zakas has a good blog post about why IE doesn't respect Array.prototype.slice.
This is to transfrom a collection into an array. If you want to cast an object to an array, please see JSLITE.toArray.
*/
//
makeArray: function (o) {
if (!JSLITE.isIE) {
return Array.prototype.slice.apply(o);
}
var iLen = o.length || 0, arr = new Array(iLen);
if (o && o.length) {
while (iLen--) {
arr[iLen] = o[iLen];
}
}
return arr;
},
//
/**
* @function JSLITE.proto
* @param {Object} oProto
* @return {Object}
* @describe
Performs prototypal inheritance. Takes an object to use as another's prototype and returns the new object.
*/
//
proto: function (oProto) {
var F = function () {};
F.prototype = oProto;
return new F();
}.assert(Object),
//
/*****************************************************************************************************************/
/*****************************************************************************************************************/
/**
* @function JSLITE.ready
* @param {Function} fn
* @return {None}
* @describe
Should be the first statement called in any jsLite application. All code to be invoked at page load should be within the function that is the sole argument.
Constant. The class names that all Tab objects use.
*/
//
JSLITE.tabClasses = {
tabs: JSLITE.globalSymbol + "_Tabs", //the class name on the containing div;
tab: JSLITE.globalSymbol + "_Tab" //the class name for each tab;
};
//
/**
* @property JSLITE.tags
* @type RegExp
* @describe
This contains all possible HTML tags. Is used by JSLITE.domQuery and JSLITE.get.dom. Is used internally but can be overwritten for any custom needs.