jLim - compact JavaScript framework

/*!
 * jLim Core
 *
 * jLim is a small JavaScript base code. It can be used to built your own
 * JavaScript library or framework.
 *
 * @version   0.1.1
 * @author    Victor Villaverde Laan
 * @link      http://www.freelancephp.net/jlim-small-javascript-framework/
 * @license   MIT license
 */
(function ( window ) {
 
/**
 * jLim function
 * @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
 * @param {string|DOM node|array of DOM nodes} context
 * @return {jLim} New instance
 */
var jLim = window.jLim = function ( selector, context ) {
	return new jLim.core.init( selector, context );
};
 
// set $ global ( when not already exists )
if ( ! window.$ )
	window.$ = jLim;
 
/**
 * jLim Core
 */
jLim.core = jLim.prototype = {
 
	els: [],
	selector: [],
	context: [],
 
	/**
	 * Init function, set selected elements
	 * @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
	 * @param {string|DOM node|array of DOM nodes} context  Optional, default is document
	 */
	init: function ( selector, context ) {
		// set selector and context property
		this.selector = selector || document;
		this.context = context || document;
 
		// get elements by selector
		if ( typeof selector == 'string' ) {
			// trim spaces at the begin and end
			selector = jLim.trim( selector );
 
			if ( selector == 'body' ) {
				// set body
				this.els = document.body;
			} else if ( selector.substr( 0, 1 ) == '<' ) {
				// create element
				this.els = jLim.create( selector );
			} else {
				// find elements
				this.els = jLim.selector( selector, context );
			}
		} else if ( jLim.isFunction( selector ) ) {
			// set DOM ready function
			jLim.ready( selector );
		} else if ( selector instanceof jLim ) {
			this.els = selector.get();
		} else {
			this.els = selector;
		}
 
		// make sure elements property is an array
		if ( ! jLim.isArray( this.els ) )
			this.els = this.els ? [ this.els ] : [];
 
		// support for using jLim object as an array
		// set indices
		for ( var i in this.els )
			this[ i ] = this.els[ i ];
 
		// set length property
		this.length = this.els.length;
	},
 
	/**
	 * Get element (return all current elements when no index given)
	 * @param {integer} index
	 * @return {DOM node|array of DOM nodes}
	 */
	get: function ( index ) {
		if ( typeof index == 'undefined' )
			return this.els;
 
		var el = ( index === -1 )
				? this.els.slice( index )
				: this.els.slice( index, +index + 1 );
 
		return el.length ? el[0] : null;
	},
 
	/**
	 * Get count of current elements
	 * @return {integer}
	 */
	size: function () {
		return this.els.length;
	},
 
	/**
	 * Call function for each element
	 * @param {function} fn
	 * @param {array} args
	 * @return {this} For chaining
	 */
	each: function ( fn, args ) {
		jLim.each( this.els, fn, args );
		return this;
	},
 
	/**
	 * Find elements within the current elements (context)
	 * @param {string} selector
	 * @return {jLim} Instance of new selection
	 */
	find: function ( selector ) {
		return this.chain( selector, this.els );
	},
 
	/**
	 * Add to the current elements in a new created jLim object
	 * @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
	 * @param {string|DOM node|array of DOM nodes} context  Optional, when none is given it will use the context of current jLim object
	 * @return {jLim} Instance of new selection
	 */
	add: function ( selector, context ) {
		var $new = this.chain( selector, context || this.context ),
			els = this.els.concat( $new.get() );
 
		$new.els = els;
		return $new;
	},
 
	/**
	 * Set one of current elements as new jLim object
	 * @param {integer} index  Negative integer also possible, -1 means last item
	 * @return {jLim} Instance of new selection
	 */
	eq: function ( index ) {
		return this.chain( this.get( index ) );
	},
 
	/**
	 * Set slice of current elements as new jLim object
	 * @param {integer} start  Like the first param of the standard Array.slice() function
	 * @param {integer} end  Like the second param of the standard Array.slice() function
	 * @return {jLim} Instance of new selection
	 */
	slice: function ( start, end ) {
		var els = this.els.slice( start, end || this.els.length );
		return this.chain( els );
	},
 
	/**
	 * Chain content as new jLim object
	 * @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
	 * @param {string|DOM node|array of DOM nodes} context  Optional
	 * @return {jLim} Instance of new selection
	 */
	chain: function ( selector, context ) {
		var $new = jLim( selector, context );
		$new.prevjLim = this;
		return $new;
	},
 
	/**
	 * Set pointer to previous jLim object
	 * @return {jLim} Previous jLim object in the chain
	 */
	end: function () {
		return this.prevjLim || jLim( null );
	}
 
};
 
// init function gets core prototype
jLim.core.init.prototype = jLim.core;
 
/**
 * Extend method
 * @return {jLim|jLim.core|object|array|boolean}
 */
jLim.extend = jLim.core.extend = function () {
	// target is current object if only one argument
	var i = 0,
		target = this,
		deep = false,
		obj, empty, item, x;
 
	// check extending recursive (deep)
	if ( typeof arguments[ 0 ] === 'boolean' ) {
		deep = true;
		i = 1;
 
		if ( arguments.length > 2 ) {
			i = 2;
			target = arguments[ 1 ];
		}
	} else if ( arguments.length > 1 ) {
		i = 1;
		target = arguments[ 0 ];
	}
 
	// loop through all source objects
	for ( x = i; x < arguments.length; x++ ) {
		obj = arguments[ x ];
 
		// copy object items (properties and methods)
		for ( item in obj ) {
			if ( obj[ item ] === target )
				continue;
 
			if ( deep && typeof obj[ item ] == 'object' && obj[ item ] !== null ) {
				// item is also object, make copy
				empty = jLim.isArray( obj[ item ] ) ? [] : {};
				target[ item ] = jLim.extend( deep, target[ item ] || empty, obj[ item ] );
			} else {
				// copy property or method
				target[ item ] = obj[ item ];
			}
		}
	}
 
	// return modified target
	return target;
};
 
/**
 * Extent basic functions
 */
jLim.extend({
 
	/**
	 * Selector method
	 * @param {string} selector
	 * @param {string|DOM node|array of DOM nodes} context  Default document
	 * @return {DOM node|array of DOM nodes|empty array}
	 */
	selector: function ( selector, context ) {
		return jLim.$$( selector, context );
	},
 
	/**
	 * Add DOMReady callbacks
	 * @param {function|string} fn  When string will be run like code with eval()
	 * @return {this}
	 */
	ready: function ( fn ) {
		// default use the DOMReady add() method
		jLim.DOMReady.add( fn );
 
		// return this for chaining
		return this;
	},
 
	/**
	 * Create DOM element
	 * @param {string} html
	 * @return {DOM element|array of DOM elements}
	 */
	create: function ( html ) {
		var ph = document.createElement( 'div' ),
			els = [];
 
		ph.innerHTML = html;
 
		// get created elements
		els = ph.childNodes;
 
		// return element or array of elements
		return els.length == 1 ? els[0] : els;
	},
 
	/**
	 * Each function for arrays and objects
	 * @param {object|array} obj
	 * @param {function} fn
	 * @return {this}
	 */
	each: function ( obj, fn ) {
		var item, retVal;
 
		// call given function for each item
		for ( item in obj ) {
			retVal = fn.call( obj[ item ], item, obj[ item ] );
 
			// do not continue further when return value is false
			if ( retVal === false )
				break;
		}
 
		// return this for chaining
		return this;
	},
 
	/**
	 * Trim spaces
	 * @param {string} str
	 * @return {string}
	 */
	trim: function ( str ) {
		return str.replace( /^\s+/, '' ).replace( /\s+$/, '' );
	},
 
	/**
	 * Check if argument is array
	 * @param {mixed} obj
	 * @return {boolean}
	 */
	isArray: function ( obj ) {
		return ( Object.prototype.toString.call( obj ) === "[object Array]" );
	},
 
	/**
	 * Check if argument is function
	 * @param {mixed} obj
	 * @return {boolean}
	 */
	isFunction: function ( obj ) {
		return ( Object.prototype.toString.call( obj ) === "[object Function]" );
	}
 
});
 
/**
 * External components
 */
 
/**
 * DOMReady
 * 
 * @version   1.0
 * @link      http://www.freelancephp.net/domready-javascript-object-cross-browser/
 * @license   MIT license
 */
jLim.DOMReady=(function(){var fns=[],isReady=false,errorHandler=null,getFunc=function(fn){if(typeof fn=='string')return function(){eval(fn);};return fn;},ready=function(){isReady=true;for(var x=0;x<fns.length;x++){try{fns[x]();}catch(err){if(errorHandler)errorHandler(err);}}};this.setOnError=function(fn){errorHandler=getFunc(fn);return this;};this.add=function(fn){fn=getFunc(fn);if(isReady){fn();}else{fns[fns.length]=fn;}return this;};if(window.addEventListener){document.addEventListener('DOMContentLoaded',function(){ready();},false);}else{(function(){if(!document.uniqueID&&document.expando)return;var tempNode=document.createElement('document:ready');try{tempNode.doScroll('left');ready();}catch(err){setTimeout(arguments.callee,0);}})();}return this;})();
 
/**
 * SS
 *
 * @version   0.1
 * @link      http://www.freelancephp.net/simple-css-selector-function/
 * @license   MIT license
 */
var $$=function(selector,context){var isObjType=function(o,type){return Object.prototype.toString.call(o)==='[object '+type+']';},isDesc=function(d,a){return d.parentNode==a||d.tagName.toUpperCase()!='HTML'&&isDesc(d.parentNode,a);},s=selector,c=context,els=[];s=s.split(',');c=isObjType(c,'String')?$$(c):c&&c.length?c:document;if(!isObjType(c,'Array'))c=[c];for(var i in c){for(var j in s){var strim=s[j].replace(/\s+/g,''),sp=s[j].split(' '),op=strim.substr(0,1),name=strim.substr(1),tels=[],nextContext;if(sp.length>1){nextContext=$$(sp[0],c[i]);tels=$$(sp.slice(1).join(' '),nextContext);els=els.concat(tels);}else if(op=='#'){tels[0]=c[i].getElementById?c[i].getElementById(name):document.getElementById(name);if(tels[0]&&isDesc(tels[0],c[i]))els.push(tels[0]);}else if(op=='.'){var expr=new RegExp('\\b'+name+'\\b'),all=c[i].getElementsByTagName('*');for(var v=0,w=all.length;v<w;v++){if(expr.test(all[v].className))els.push(all[v]);}}else{tels=c[i].getElementsByTagName(strim);for(var y=0,z=tels.length;y<z;y++)els.push(tels[y]);}}}return els.length==1?els[0]:els;};
jLim.$$=$$;
 
})( window );