/**
 * jLim Core
 *
 * @fileOverview
 *    Contains basic methods for jLim framework.
 *    Released under MIT license.
 * @package jLim
 * @requires DOMReady and SimpleSelector
 * @author Victor Villaverde Laan
 * @link http://www.freelancephp.net/jlim-small-javascript-framework/
 * @link https://github.com/freelancephp/jLim
 */
(function (window, SS, DOMReady) {

/**
 * jLim factory function
 * @namespace jLim
 * @param {String|DOMElement|DOMElement[]} selector
 * @param {String|DOMElement|DOMElement[]} [context=document] !! Will be ignored if selector is not a string !!
 * @return {jLim.fn.init} New instance
 */
var jLim = function (selector, context) {
		return new jLim.fn.init(selector, context);
	},
	original$ = window.$,
	$ = jLim,
	$$ = SS.select,
	document = window.document;

/**
 * jLim functions
 * @namespace jLim.fn
 */
$.fn = {

	/**
	 * @property {DOMElement[]} els Selected elements
	 */
	els: [],

	/**
	 * @property {String|DOMElement|DOMElement[]} selector Selector used for selection
	 */
	selector: [],

	/**
	 * @property {String|DOMElement|DOMElement[]} context Context used for the selection
	 */
	context: [],

	/**
	 * Set elements for given selection.
	 * @constructor
	 * @param {String|DOMElement|DOMElement[]} selector
	 * @param {String|DOMElement|DOMElement[]} [context=document] !! Will be ignored if selector is not a string !!
	 */
	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 = $.trim(selector);

			if (selector == 'body' && ! context){
				// set body
				this.els = document.body;
			} else if (selector.substr( 0, 1 ) == '<'){
				// create element
				this.els = $.create(selector);
			} else {
				// find elements
				this.els = $.selector(selector, context);
			}
		} else if ($.isFunction(selector)){
			// set DOM ready function
			$.ready( selector );
		} else if (selector instanceof $.fn.init){
			this.els = selector.get();
		} else {
			this.els = selector;
		}

		// make sure elements property is an array
		if (!$.isArray(this.els)) {
			this.els = this.els ? [this.els] : [];
		} else {
			// remove doubles
			this.els = $.clearDuplicates(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 is given)
	 * @param {Integer} index
	 * @return {DOMElement|DOMElement[]}
	 */
	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}
	 */
	each: function (fn) {
		$.each(this.els, fn);
		return this;
	},

	/**
	 * Find elements within the current elements (context)
	 * @param {String} selector
	 * @return {jLim.fn.init} 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|DOMElement|DOMElement[]} selector When selector is not a string the context will be ignored
	 * @param {String|DOMElement|DOMElement[]} [context]
	 * @return {jLim.fn.init} Instance of new selection
	 */
	add: function (selector, context) {
		var $new = this.chain(selector, context),
			els = this.els.concat($new.get());

		$new.els = $.clearDuplicates(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.fn.init} 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.fn.init} Instance of new selection
	 */
	slice: function (start, end) {
		var els = this.els.slice(start, end || this.els.length);
		return this.chain(els);
	},

	/**
	 * Get index of given element
	 * @param {String|DOMElement|DOMElement[]} When more than one element, only the index of the first will be returned
	 * @return {Integer} Index of given element
	 */
	index: function (element) {
		var el = jLim(element).get(0);

		for (var x = 0, y = this.length; x < y; x++) {
			if (this.els[x] === el)
				return x;
		}

		return null;
	},

	/**
	 * Chain completely new jLim object
	 * @param {String|DOMElement|DOMElement[]} selector When selector is not a string the context will be ignored
	 * @param {String|DOMElement|DOMElement[]} [context]
	 * @return {jLim.fn.init} 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.fn.init} Previous jLim object in the chain
	 */
	end: function () {
		return this.prevjLim || jLim(null);
	}

};

/**
 * @memberOf jLim.fn
 * @deprecated Use .chain() method instead
 */
$.fn.$ = $.fn.chain;

/**
 * @class jLim.fn.init
 * @exports jLim.fn as this.prototype
 */
$.fn.init.prototype = $.fn;

/**
 * For extending objects
 * @memberOf jLim
 * @memberOf jLim.fn
 * @return {Object|Array}
 */
$.extend = $.fn.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 = $.isArray(obj[item]) ? [] : {};
				target[item] = $.extend(deep, target[item] || empty, obj[item]);
			} else {
				// copy property or method
				target[item] = obj[item];
			}
		}
	}

	// return modified target
	return target;
};

$.extend(
	/**
	 * @lends jLim
	 */
	{
		/**
		 * Prevent conflicts with $ namespace
		 * @return jLim
		 */
		noConflict: function () {
			window.$ = original$;
			return jLim;
		},

		/**
		 * Selector method
		 * @param {String} selector
		 * @param {String|DOMElement|DOMElement[]} [context=document]
		 * @return {DOMElement|DOMElement[]|Array}
		 */
		selector: function (selector, context) {
			return $$(selector, context);
		},

		/**
		 * Add callbacks for when DOM is ready
		 * @param {Function} fn
		 */
		ready: function (fn) {
			DOMReady.add(fn, [jLim]);
		},

		/**
		 * Create DOM element
		 * @param {String} html
		 * @return {DOMElement|DOMElement[]}
		 */
		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
		 */
		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;
			}
		},

		/**
		 * Trim spaces (also tabs and linefeeds)
		 * @param {String} str
		 * @return {String}
		 */
		trim: function (str) {
			return str.replace(/^\s+/, '').replace(/\s+$/, '');
		},

		/**
		 * Check if item exists in array
		 * @param {Array} arr
		 * @param {Mixed} item
		 * @return {Boolean}
		 */
		itemExists: function (arr, item) {
			return SS.itemExists(arr, item);
		},

		/**
		 * Return array without duplicate entries
		 * @param {Array} arr
		 * @return {Array}
		 */
		clearDuplicates: function (arr) {
			return SS.clearDuplicates(arr);
		},

		/**
		 * 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]';
		}
	}
);

/**
 * Make jLim global
 * @ignore
 */
window.jLim = window.$ = jLim;

})(window, SimpleSelector, DOMReady);

/*!
 * 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 );

http://www.freelancephp.net/jlim-small-javascript-framework/

jLim is a small JavaScript base code. It can be used to built your own JavaScript library or framework.

jLim - compact JavaScript framework

javascript, js, jquery

JavaScript