2011-06-11 17:08:00 -04:00
/ * *
2011-06-30 19:53:50 -04:00
Kis JS Keep It Simple JS Library
Copyright Timothy J . Warren
License Public Domain
2013-06-19 10:13:21 -04:00
Version 0.8 . 0
2011-06-29 11:34:05 -04:00
* /
2013-06-19 10:13:21 -04:00
( function ( undefined ) {
2011-06-11 17:08:00 -04:00
2011-07-14 21:53:16 -04:00
"use strict" ;
2011-06-29 11:34:05 -04:00
2013-12-11 21:37:51 -05:00
var $ _ , $ , sel ;
2012-03-29 12:05:11 -04:00
2011-06-29 11:34:05 -04:00
2011-07-07 17:45:18 -04:00
/ * *
* $ _
*
* Constructor function
2011-11-01 18:56:27 -04:00
*
* @ constuctor
* @ namespace
* @ param string selector
* @ return object
2011-07-07 17:45:18 -04:00
* /
2011-07-14 21:52:17 -04:00
$ _ = function ( s )
2011-07-07 17:45:18 -04:00
{
2012-10-04 13:25:09 -04:00
// Have documentElement be default selector, just in case
2013-06-19 10:13:21 -04:00
if ( s === undefined )
2011-07-14 21:52:17 -04:00
{
2012-10-04 13:25:09 -04:00
// Defines a "global" selector for that instance
2013-06-19 10:13:21 -04:00
sel = ( $ _ . el !== undefined )
2011-07-14 21:52:17 -04:00
? $ _ . el
: document . documentElement ;
}
else
2011-07-07 17:45:18 -04:00
{
2012-10-04 13:25:09 -04:00
sel = $ ( s ) ;
2011-07-07 17:45:18 -04:00
}
2012-03-29 12:05:11 -04:00
2011-10-20 17:31:29 -04:00
// Add the selector to the prototype
$ _ . prototype . el = sel ;
2011-07-19 20:33:56 -04:00
2012-04-06 10:40:53 -04:00
// Use the $_ object as it's own prototype
2013-12-11 21:37:51 -05:00
var self = Object . create ( $ _ ) ;
2011-07-19 20:33:56 -04:00
// Give sel to each extension.
2012-03-29 12:05:11 -04:00
for ( var i in self )
2011-07-19 20:33:56 -04:00
{
if ( typeof self [ i ] === "object" )
2011-07-20 08:22:13 -04:00
{
self [ i ] . el = sel ;
2012-03-29 12:05:11 -04:00
}
2011-07-19 20:33:56 -04:00
}
2011-07-14 00:41:34 -04:00
self . el = sel ;
2012-03-29 12:05:11 -04:00
2011-07-14 00:41:34 -04:00
return self ;
2011-07-12 13:30:58 -04:00
} ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Simple DOM selector function
*
* @ memberOf $ _
* @ param string selector
2011-11-03 16:04:35 -04:00
* @ param object context
2011-11-01 18:56:27 -04:00
* @ return object
* @ type object
* /
$ = function ( a , context )
{
var x , c ;
2012-03-29 12:05:11 -04:00
2013-06-19 10:13:21 -04:00
if ( typeof a != "string" || a === undefined ) { return a ; }
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
//Check for a context of a specific element, otherwise, just run on the document
2012-03-29 12:05:11 -04:00
c = ( context != null && context . nodeType === 1 )
? context
2011-11-01 18:56:27 -04:00
: document ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
//Pick the quickest method for each kind of selector
if ( a . match ( /^#([\w\-]+$)/ ) )
{
return document . getElementById ( a . split ( '#' ) [ 1 ] ) ;
}
else
{
x = c . querySelectorAll ( a ) ;
}
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
//Return the single object if applicable
return ( x . length === 1 ) ? x [ 0 ] : x ;
} ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Adds the property ` obj ` to the $ _ object , calling it ` name `
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ param string name
* @ param object obj
* /
2011-07-14 21:52:17 -04:00
$ _ . ext = function ( name , obj )
2011-07-07 17:45:18 -04:00
{
2011-07-14 21:52:17 -04:00
obj . el = sel ;
2011-08-10 16:30:36 -04:00
$ _ [ name ] = obj ;
2011-07-14 21:52:17 -04:00
} ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Iterates over a $ _ object , applying a callback to each item
*
* @ name $ _ . each
* @ function
* @ param function callback
* /
2011-07-14 21:52:17 -04:00
$ _ . ext ( 'each' , function ( callback )
2011-07-20 13:03:21 -04:00
{
2013-06-19 10:13:21 -04:00
if ( sel . length !== undefined && sel !== window )
2011-07-07 17:45:18 -04:00
{
2013-12-11 21:37:51 -05:00
[ ] . forEach . call ( sel , callback ) ;
2011-07-07 17:45:18 -04:00
}
2011-07-08 13:03:38 -04:00
else
{
2011-11-02 19:12:58 -04:00
callback . call ( sel , sel ) ;
2011-07-08 13:03:38 -04:00
}
2011-07-14 21:52:17 -04:00
} ) ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Retrieves the type of the passed variable
*
* @ param mixed obj
* @ return string
* @ type string
* /
2012-03-29 12:05:11 -04:00
$ _ . type = function ( obj )
{
2011-08-10 16:30:36 -04:00
if ( ( function ( ) { return obj && ( obj !== this ) } ) . call ( obj ) )
{
//fallback on 'typeof' for truthy primitive values
return ( typeof obj ) . toLowerCase ( ) ;
}
2012-03-29 12:05:11 -04:00
//Strip x from [object x] and return
2011-08-10 16:30:36 -04:00
return ( { } ) . toString . call ( obj ) . match ( /\s([a-z|A-Z]+)/ ) [ 1 ] . toLowerCase ( ) ;
2011-10-31 11:56:59 -04:00
} ;
2011-07-14 21:52:17 -04:00
//Set global variables
$ _ = window . $ _ = window . $ _ || $ _ ;
$ _ . $ = $ ;
2011-11-02 12:10:58 -04:00
} ( ) ) ;
2013-12-11 21:37:51 -05:00
2011-11-02 12:10:58 -04:00
// --------------------------------------------------------------------------
/ * *
* A module of various browser polyfills
* @ file polyfill . js
* /
2012-04-05 18:39:10 -04:00
/ * *
* String trim function polyfill
* /
if ( typeof String . prototype . trim === "undefined" )
{
2011-07-14 21:52:17 -04:00
/ * *
2012-04-05 18:39:10 -04:00
* @ private
2011-07-14 21:52:17 -04:00
* /
2012-04-05 18:39:10 -04:00
String . prototype . trim = function ( )
2011-11-03 16:04:35 -04:00
{
2012-04-05 18:39:10 -04:00
return this . replace ( /^[\s\uFEFF]+|[\s\uFEFF]+$/g , "" ) ;
} ;
}
2012-01-24 08:55:21 -05:00
2012-04-05 18:39:10 -04:00
// --------------------------------------------------------------------------
2012-03-29 12:05:11 -04:00
2012-04-05 18:39:10 -04:00
/ * *
* Array . isArray polyfill
* /
if ( typeof Array . isArray === "undefined" )
{
Array . isArray = function ( v )
2012-04-05 16:32:05 -04:00
{
2012-04-05 18:39:10 -04:00
return Object . prototype . toString . apply ( v ) === '[object Array]' ;
2012-04-05 16:32:05 -04:00
}
2012-04-05 18:39:10 -04:00
}
2012-03-29 12:05:11 -04:00
2012-04-05 18:39:10 -04:00
// --------------------------------------------------------------------------
2013-06-19 10:13:21 -04:00
( function ( $ _ , undefined ) {
2012-04-05 18:39:10 -04:00
"use strict"
2012-01-24 08:55:21 -05:00
// --------------------------------------------------------------------------
2012-04-26 13:21:47 -04:00
//This is used so IE can use the classList api
2013-06-19 10:13:21 -04:00
/*! @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js*/
if ( typeof document !== "undefined" && ! ( "classList" in document . createElement ( "a" ) ) ) { ( function ( j ) { if ( ! ( "HTMLElement" in j ) && ! ( "Element" in j ) ) { return } var a = "classList" , f = "prototype" , m = ( j . HTMLElement || j . Element ) [ f ] , b = Object , k = String [ f ] . trim || function ( ) { return this . replace ( /^\s+|\s+$/g , "" ) } , c = Array [ f ] . indexOf || function ( q ) { var p = 0 , o = this . length ; for ( ; p < o ; p ++ ) { if ( p in this && this [ p ] === q ) { return p } } return - 1 } , n = function ( o , p ) { this . name = o ; this . code = DOMException [ o ] ; this . message = p } , g = function ( p , o ) { if ( o === "" ) { throw new n ( "SYNTAX_ERR" , "An invalid or illegal string was specified" ) } if ( /\s/ . test ( o ) ) { throw new n ( "INVALID_CHARACTER_ERR" , "String contains an invalid character" ) } return c . call ( p , o ) } , d = function ( s ) { var r = k . call ( s . className ) , q = r ? r . split ( /\s+/ ) : [ ] , p = 0 , o = q . length ; for ( ; p < o ; p ++ ) { this . push ( q [ p ] ) } this . _updateClassName = function ( ) { s . className = this . toString ( ) } } , e = d [ f ] = [ ] , i = function ( ) { return new d ( this ) } ; n [ f ] = Error [ f ] ; e . item = function ( o ) { return this [ o ] || null } ; e . contains = function ( o ) { o += "" ; return g ( this , o ) !== - 1 } ; e . add = function ( ) { var s = arguments , r = 0 , p = s . length , q , o = false ; do { q = s [ r ] + "" ; if ( g ( this , q ) === - 1 ) { this . push ( q ) ; o = true } } while ( ++ r < p ) ; if ( o ) { this . _updateClassName ( ) } } ; e . remove = function ( ) { var t = arguments , s = 0 , p = t . length , r , o = false ; do { r = t [ s ] + "" ; var q = g ( this , r ) ; if ( q !== - 1 ) { this . splice ( q , 1 ) ; o = true } } while ( ++ s < p ) ; if ( o ) { this . _updateClassName ( ) } } ; e . toggle = function ( p , q ) { p += "" ; var o = this . contains ( p ) , r = o ? q !== true && "remove" : q !== false && "add" ; if ( r ) { this [ r ] ( p ) } return ! o } ; e . toString = function ( ) { return this . join ( " " ) } ; if ( b . defineProperty ) { var l = { get : i , enumerable : true , configurable : true } ; try { b . defineProperty ( m , a , l ) } catch ( h ) { if ( h . number === - 2146823252 ) { l . enumerable = false ; b . defineProperty ( m , a , l ) } } } else { if ( b [ f ] . _ _defineGetter _ _ ) { m . _ _defineGetter _ _ ( a , i ) } } } ( self ) ) } ;
2011-10-24 12:35:48 -04:00
2011-11-02 12:10:58 -04:00
/ * *
* DOM
2012-03-29 12:05:11 -04:00
*
2011-11-02 12:10:58 -04:00
* Dom manipulation module
* /
2011-11-01 20:14:38 -04:00
2012-04-05 18:39:10 -04:00
2011-11-03 16:04:35 -04:00
var d ;
2012-03-29 12:05:11 -04:00
2011-11-15 12:03:12 -05:00
//Private function for getting/setting attributes/properties
2011-10-24 12:35:48 -04:00
function _attr ( sel , name , value )
{
var oldVal , doAttr ;
//Get the value of the attribute, if it exists
2013-06-19 10:13:21 -04:00
if ( sel . hasAttribute !== undefined )
2011-10-24 12:35:48 -04:00
{
if ( sel . hasAttribute ( name ) )
2011-10-24 12:26:00 -04:00
{
2011-10-24 12:35:48 -04:00
oldVal = sel . getAttribute ( name ) ;
2011-10-24 12:26:00 -04:00
}
2011-06-29 11:34:05 -04:00
2011-10-24 12:35:48 -04:00
doAttr = true ;
2011-10-24 12:24:10 -04:00
}
2013-06-19 10:13:21 -04:00
else if ( sel [ name ] !== undefined )
2011-10-24 12:24:10 -04:00
{
2011-10-24 12:35:48 -04:00
oldVal = sel [ name ] ;
doAttr = false ;
}
2013-06-19 10:13:21 -04:00
else if ( name === "class" && sel . className !== undefined ) //className attribute
2011-10-24 12:35:48 -04:00
{
name = "className" ;
oldVal = sel . className ;
doAttr = false ;
2011-10-24 12:26:00 -04:00
}
2011-10-24 12:35:48 -04:00
//Well, I guess that attribute doesn't exist
2013-06-19 10:13:21 -04:00
if ( oldVal === undefined && ( value === undefined || value === null ) )
2011-10-24 12:24:10 -04:00
{
2012-03-29 12:05:11 -04:00
return null ;
2011-10-24 12:35:48 -04:00
}
//No value to set? Return the current value
2013-06-19 10:13:21 -04:00
if ( value === undefined )
2011-10-24 12:35:48 -04:00
{
return oldVal ;
}
//Determine what to do with the attribute
2013-06-19 10:13:21 -04:00
if ( value !== undefined && value !== null )
2011-10-24 12:35:48 -04:00
{
if ( doAttr === true )
2011-07-25 10:06:39 -04:00
{
2011-10-24 12:35:48 -04:00
sel . setAttribute ( name , value ) ;
2011-10-24 12:26:00 -04:00
}
2011-10-24 12:35:48 -04:00
else
2011-10-24 12:26:00 -04:00
{
2011-10-24 12:35:48 -04:00
sel [ name ] = value ;
2012-03-29 12:05:11 -04:00
}
2011-10-24 12:35:48 -04:00
}
else if ( value === null )
{
if ( doAttr === true )
2011-10-24 12:26:00 -04:00
{
2011-10-24 12:35:48 -04:00
sel . removeAttribute ( name ) ;
2011-10-24 12:26:00 -04:00
}
2011-10-24 12:35:48 -04:00
else
2011-10-24 12:24:10 -04:00
{
2011-10-24 12:35:48 -04:00
delete sel [ name ] ;
2012-03-29 12:05:11 -04:00
}
2011-10-24 12:26:00 -04:00
}
2011-10-24 12:35:48 -04:00
2013-06-19 10:13:21 -04:00
return ( value !== undefined ) ? value : oldVal ;
2011-10-24 12:35:48 -04:00
}
2012-03-29 12:05:11 -04:00
2012-02-23 12:42:33 -05:00
/ * *
* Change css property name to it ' s
* javascript camel case equivalent
* /
2011-10-24 12:35:48 -04:00
function _toCamel ( s )
{
return s . replace ( /(\-[a-z])/g , function ( $1 ) {
return $1 . toUpperCase ( ) . replace ( '-' , '' ) ;
} ) ;
}
function _css ( sel , prop , val )
{
var equi ;
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
//Camel-case
prop = _toCamel ( prop ) ;
//Equivalent properties for 'special' browsers
equi = {
outerHeight : "offsetHeight" ,
outerWidth : "offsetWidth" ,
top : "posTop"
} ;
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
//If you don't define a value, try returning the existing value
2013-06-19 10:13:21 -04:00
if ( val === undefined && sel . style [ prop ] !== undefined )
2011-10-24 12:35:48 -04:00
{
return sel . style [ prop ] ;
}
2013-06-19 10:13:21 -04:00
else if ( val === undefined && sel . style [ equi [ prop ] ] !== undefined )
2011-10-24 12:35:48 -04:00
{
return sel . style [ equi [ prop ] ] ;
}
2011-10-24 12:26:00 -04:00
2011-10-24 12:35:48 -04:00
//Let's try the easy way first
2013-06-19 10:13:21 -04:00
if ( sel . style [ prop ] !== undefined )
2011-10-24 12:35:48 -04:00
{
sel . style [ prop ] = val ;
2011-07-25 10:06:39 -04:00
2011-10-24 12:35:48 -04:00
//Short circuit
2012-03-29 12:05:11 -04:00
return null ;
2011-10-24 12:35:48 -04:00
}
else if ( sel . style [ equi [ prop ] ] )
{
sel . style [ equi [ prop ] ] = val ;
2012-03-29 12:05:11 -04:00
return null ;
2011-10-24 12:35:48 -04:00
}
}
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
// --------------------------------------------------------------------------
2011-10-24 12:26:00 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* DOM
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* Dom manipulation module
* @ namespace
* @ memberOf $ _
* @ name dom
* /
2011-10-24 12:35:48 -04:00
d = {
2011-11-01 18:56:27 -04:00
/ * *
* Adds a class to the element ( s ) specified by the current
* selector
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name addClass
* @ memberOf $ _ . dom
* @ function
* @ param string class
* /
2011-10-24 12:35:48 -04:00
addClass : function ( c )
{
$ _ . each ( function ( e ) {
2013-12-11 21:37:51 -05:00
e . classList . add ( c ) ;
2011-10-24 12:35:48 -04:00
} ) ;
} ,
2011-11-01 18:56:27 -04:00
/ * *
* Removes a class from the element ( s ) specified by the current
* selector
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name removeClass
* @ memberOf $ _ . dom
* @ function
* @ param string class
* /
2011-10-24 12:35:48 -04:00
removeClass : function ( c )
{
$ _ . each ( function ( e ) {
e . classList . remove ( c ) ;
} ) ;
} ,
2011-11-01 18:56:27 -04:00
/ * *
* Hides the element ( s ) specified by the current selector
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name hide
* @ memberOf $ _ . dom
* @ function
* /
2011-10-24 12:35:48 -04:00
hide : function ( )
{
this . css ( 'display' , 'none' ) ;
} ,
2011-11-01 18:56:27 -04:00
/ * *
2012-03-29 12:05:11 -04:00
* Shows the element ( s ) specified by the current selector .
2011-11-01 18:56:27 -04:00
* if type is specified , the element will have it ' s style
* property set to "display:[your type]" . If type is not
* specified , the element is set to "display:block" .
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name show
* @ memberOf $ _ . dom
* @ function
* @ param [ string ] type
* /
2011-10-24 12:35:48 -04:00
show : function ( type )
{
2013-06-19 10:13:21 -04:00
if ( type === undefined )
2011-10-18 11:16:51 -04:00
{
2011-10-24 12:35:48 -04:00
type = "block" ;
}
2011-10-24 12:26:00 -04:00
2011-10-24 12:35:48 -04:00
this . css ( "display" , type ) ;
} ,
2011-11-01 18:56:27 -04:00
/ * *
2012-03-29 12:05:11 -04:00
* Sets attributes on element ( s ) specified by the current
* selector , or , if name is not specified , returns the
2011-11-01 18:56:27 -04:00
* value of the attribute of the element specified by the
* current selector .
*
* @ name attr
* @ memberOf $ _ . dom
* @ function
* @ param string name
2011-11-03 16:04:35 -04:00
* @ param [ string ] value
2011-11-01 18:56:27 -04:00
* @ return string
* @ type string
* /
2011-10-24 12:35:48 -04:00
attr : function ( name , value )
{
var sel = this . el ;
//Make sure you don't try to get a bunch of elements
2013-06-19 10:13:21 -04:00
if ( sel . length > 1 && value === undefined )
2011-10-24 12:35:48 -04:00
{
2012-04-26 13:21:47 -04:00
return null ;
2011-10-24 12:35:48 -04:00
}
2013-06-19 10:13:21 -04:00
else if ( sel . length > 1 && value !== undefined ) //You can set a bunch, though
2011-06-11 17:08:00 -04:00
{
2011-10-24 12:26:00 -04:00
$ _ . each ( function ( e ) {
2011-10-24 12:35:48 -04:00
return _attr ( e , name , value ) ;
2011-10-24 12:26:00 -04:00
} ) ;
2011-10-24 12:24:10 -04:00
}
2011-10-24 12:35:48 -04:00
else //Normal behavior
{
return _attr ( sel , name , value ) ;
}
} ,
2011-11-01 18:56:27 -04:00
/ * *
* Sets or retrieves the text content of the element
2012-03-29 12:05:11 -04:00
* specified by the current selector . If a value is
2011-11-01 18:56:27 -04:00
* passed , it will set that value on the current element ,
* otherwise it will return the value of the current element
*
* @ name text
2011-11-02 19:12:58 -04:00
* @ memberOf $ _ . dom
2011-11-01 18:56:27 -04:00
* @ function
* @ param [ string ] value
2011-11-03 16:04:35 -04:00
* @ return string
2011-11-01 18:56:27 -04:00
* @ type string
* /
2011-10-24 12:35:48 -04:00
text : function ( value )
{
2012-10-04 13:25:09 -04:00
var oldValue , set , sel ;
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
sel = this . el ;
2012-03-29 12:05:11 -04:00
2013-06-19 10:13:21 -04:00
set = ( value !== undefined ) ? true : false ;
2012-03-29 12:05:11 -04:00
2012-10-04 13:25:09 -04:00
oldValue = sel . textContent ;
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
if ( set )
2011-10-24 12:26:00 -04:00
{
2012-10-04 13:25:09 -04:00
sel . textContent = value ;
2011-10-24 12:35:48 -04:00
return value ;
}
else
2011-10-24 12:24:10 -04:00
{
2011-10-24 12:35:48 -04:00
return oldValue ;
}
} ,
2011-11-01 18:56:27 -04:00
/ * *
* Sets or retrieves a css property of the element
2012-03-29 12:05:11 -04:00
* specified by the current selector . If a value is
2011-11-01 18:56:27 -04:00
* passed , it will set that value on the current element ,
* otherwise it will return the value of the css property
* on the current element
*
* @ name css
2011-11-02 19:12:58 -04:00
* @ memberOf $ _ . dom
2011-11-01 18:56:27 -04:00
* @ function
* @ param string property
* @ param [ string ] value
2011-11-03 16:04:35 -04:00
* @ return string
2011-11-01 18:56:27 -04:00
* @ type string
* /
2011-10-24 12:35:48 -04:00
css : function ( prop , val )
{
//Return the current value if a value is not set
2013-06-19 10:13:21 -04:00
if ( val === undefined )
2011-10-24 12:26:00 -04:00
{
2011-10-24 12:35:48 -04:00
return _css ( this . el , prop ) ;
}
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
$ _ . each ( function ( e ) {
_css ( e , prop , val ) ;
} ) ;
2011-11-02 19:12:58 -04:00
} ,
2011-11-22 15:23:50 -05:00
/ * *
* Adds to the innerHTML of the current element , after the last child .
2012-03-29 12:05:11 -04:00
*
2011-11-22 15:23:50 -05:00
* @ example $ _ ( "ul" ) . dom . append ( "<li></li>" ) adds an li element to the end of the selected ul element
* @ name append
* @ memberOf $ _ . dom
* @ function
* @ param string htm
* /
append : function ( htm )
{
2013-06-19 10:13:21 -04:00
if ( document . insertAdjacentHTML !== undefined )
2011-12-06 11:47:22 -05:00
{
this . el . insertAdjacentHTML ( 'beforeend' , htm ) ;
}
else
{
this . el . innerHTML += htm ;
}
2011-11-22 15:23:50 -05:00
} ,
/ * *
* Adds to the innerHTML of the selected element , before the current children
2012-03-29 12:05:11 -04:00
*
2011-11-22 15:23:50 -05:00
* @ name prepend
* @ memberOf $ _ . dom
* @ function
* @ param string htm
* /
prepend : function ( htm )
{
2013-06-19 10:13:21 -04:00
if ( document . insertAdjacentHTML !== undefined )
2011-12-06 11:47:22 -05:00
{
this . el . insertAdjacentHTML ( 'afterbegin' , htm ) ;
}
else
{
this . el . innerHTML = htm + this . el . innerHTML ;
}
2011-11-22 15:23:50 -05:00
} ,
2011-11-02 19:12:58 -04:00
/ * *
* Sets or gets the innerHTML propery of the element ( s ) passed
*
* @ name html
* @ memberOf $ _ . dom
* @ function
2011-11-03 16:04:35 -04:00
* @ param [ string ] htm
2011-11-02 19:12:58 -04:00
* @ return string
* @ type string
* /
html : function ( htm )
{
2012-03-29 12:05:11 -04:00
2013-06-19 10:13:21 -04:00
if ( htm !== undefined )
2011-11-02 19:12:58 -04:00
{
this . el . innerHTML = htm ;
}
2012-03-29 12:05:11 -04:00
2011-11-02 19:12:58 -04:00
//If the parameter is undefined, just return the current value
return this . el . innerHTML ;
2011-10-24 12:35:48 -04:00
}
} ;
2011-10-24 12:26:00 -04:00
2011-10-24 12:35:48 -04:00
$ _ . ext ( 'dom' , d ) ;
2012-03-29 12:05:11 -04:00
2012-04-05 18:39:10 -04:00
2011-10-24 12:26:00 -04:00
2011-10-24 12:35:48 -04:00
// --------------------------------------------------------------------------
2011-07-25 10:06:39 -04:00
2011-10-24 12:35:48 -04:00
/ * *
* Ajax
*
2011-11-01 18:56:27 -04:00
* Module for making ajax requests
2011-10-24 12:35:48 -04:00
* /
2012-03-29 12:05:11 -04:00
2012-04-05 18:39:10 -04:00
2011-10-24 12:35:48 -04:00
var ajax = {
2012-04-19 08:16:04 -04:00
_do : function ( url , data , success _callback , error _callback , isPost )
2011-10-24 12:35:48 -04:00
{
2012-03-29 12:05:11 -04:00
var type ,
2011-11-02 19:12:58 -04:00
request = new XMLHttpRequest ( ) ;
2012-03-29 12:05:11 -04:00
2013-06-19 10:13:21 -04:00
if ( success _callback === undefined )
2011-06-29 11:34:05 -04:00
{
2011-11-01 18:56:27 -04:00
/ * *
* @ private
* /
2012-04-19 08:16:04 -04:00
success _callback = function ( ) { } ;
2011-10-24 12:35:48 -04:00
}
2011-06-29 11:34:05 -04:00
2011-11-02 19:12:58 -04:00
type = ( isPost ) ? "POST" : "GET" ;
2012-11-16 14:02:25 -05:00
2012-11-15 13:42:14 -05:00
if ( type === "GET" )
{
2012-11-16 14:02:25 -05:00
url += ( url . match ( /\?/ ) )
? this . _serialize ( data )
: "?" + this . _serialize ( data ) ;
2012-11-15 13:42:14 -05:00
}
2012-03-29 12:05:11 -04:00
2011-10-24 12:35:48 -04:00
request . open ( type , url ) ;
2011-07-14 21:52:17 -04:00
2011-10-24 12:35:48 -04:00
request . onreadystatechange = function ( )
{
if ( request . readyState === 4 )
2011-06-23 13:16:02 -04:00
{
2012-04-19 08:16:04 -04:00
if ( request . status === 200 )
{
success _callback . call ( request . responseText , request . responseText ) ;
}
else
{
2013-06-19 10:13:21 -04:00
if ( error _callback !== undefined )
2012-04-19 08:16:04 -04:00
{
error _callback . call ( request . status , request . status ) ;
}
}
2012-10-04 13:25:09 -04:00
2011-10-24 12:35:48 -04:00
}
} ;
if ( type === "POST" )
{
request . setRequestHeader ( "Content-Type" , "application/x-www-form-urlencoded" ) ;
request . send ( this . _serialize ( data ) ) ;
}
else
{
request . send ( null ) ;
}
} ,
_serialize : function ( data )
{
2011-11-02 19:12:58 -04:00
var name ,
value ,
pairs = [ ] ;
2011-07-14 21:52:17 -04:00
2011-11-02 19:12:58 -04:00
for ( name in data )
2011-10-24 12:35:48 -04:00
{
2013-12-11 21:37:51 -05:00
if ( ! data . hasOwnProperty ( name ) || typeof data [ name ] === "function" )
2011-06-23 13:16:02 -04:00
{
2011-10-24 12:35:48 -04:00
continue ;
2011-06-23 13:16:02 -04:00
}
2011-06-29 11:34:05 -04:00
2011-11-02 19:12:58 -04:00
value = data [ name ] . toString ( ) ;
2011-06-29 11:34:05 -04:00
2011-10-24 12:35:48 -04:00
name = encodeURIComponent ( name ) ;
value = encodeURIComponent ( value ) ;
2011-07-06 22:03:59 -04:00
2011-10-24 12:35:48 -04:00
pairs . push ( name + "=" + value ) ;
}
2011-07-06 22:03:59 -04:00
2011-10-24 12:35:48 -04:00
return pairs . join ( "&" ) ;
}
} ;
2011-07-25 10:06:39 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Sends a GET type ajax request
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name get
* @ function
* @ memberOf $ _
* @ param string url
* @ param object data
2012-04-19 08:16:04 -04:00
* @ param function success _callback
* @ param function error _callback
2011-11-01 18:56:27 -04:00
* /
2012-04-19 08:16:04 -04:00
$ _ . ext ( 'get' , function ( url , data , success _callback , error _callback ) {
ajax . _do ( url , data , success _callback , error _callback , false ) ;
2011-10-24 12:35:48 -04:00
} ) ;
2012-03-29 12:05:11 -04:00
2011-11-01 18:56:27 -04:00
/ * *
* Sends a POST type ajax request
2012-03-29 12:05:11 -04:00
*
2011-11-01 18:56:27 -04:00
* @ name post
* @ function
* @ memberOf $ _
* @ param string url
* @ param object data
2012-04-19 08:16:04 -04:00
* @ param function success _callback
* @ param function error _callback
2011-11-01 18:56:27 -04:00
* /
2012-04-19 08:16:04 -04:00
$ _ . ext ( 'post' , function ( url , data , success _callback , error _callback ) {
ajax . _do ( url , data , success _callback , error _callback , true ) ;
2011-10-24 12:35:48 -04:00
} ) ;
2012-10-04 13:25:09 -04:00
2011-07-06 22:03:59 -04:00
2011-10-24 12:35:48 -04:00
// --------------------------------------------------------------------------
2011-10-20 17:31:29 -04:00
2012-02-08 11:36:43 -05:00
/ * *
2012-02-08 11:54:46 -05:00
* Event
*
* Event api wrapper
2012-03-29 12:05:11 -04:00
* @ todo Add method for triggering events
2012-02-08 11:36:43 -05:00
* /
2012-04-05 18:39:10 -04:00
2012-10-04 13:25:09 -04:00
var _add _remove , e , _attach _delegate ;
2012-02-08 11:54:46 -05:00
_add _remove = function ( sel , event , callback , add )
{
var i , len ;
2012-03-29 12:05:11 -04:00
2013-06-19 10:13:21 -04:00
if ( sel === undefined )
2012-02-08 11:54:46 -05:00
{
2012-04-26 13:21:47 -04:00
return null ;
2012-02-08 11:54:46 -05:00
}
// Multiple events? Run recursively!
2012-02-23 12:42:33 -05:00
if ( ! event . match ( /^([\w\-]+)$/ ) )
2012-02-08 11:54:46 -05:00
{
event = event . split ( " " ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
len = event . length ;
for ( i = 0 ; i < len ; i ++ )
2011-06-29 11:34:05 -04:00
{
2012-02-08 11:54:46 -05:00
_add _remove ( sel , event [ i ] , callback , add ) ;
2011-10-24 12:35:48 -04:00
}
2012-02-08 11:54:46 -05:00
return ;
}
2012-10-04 13:25:09 -04:00
// Bind the event
( add === true )
? sel . addEventListener ( event , callback , false )
: sel . removeEventListener ( event , callback , false ) ;
2012-02-08 11:54:46 -05:00
} ;
_attach _delegate = function ( sel , target , event , callback )
{
// attach the listener to the parent object
_add _remove ( sel , event , function ( e ) {
2012-03-29 12:05:11 -04:00
2012-10-04 13:25:09 -04:00
var elem , t ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Get the live version of the target selector
2012-02-23 12:42:33 -05:00
t = $ _ . $ ( target , sel ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Check each element to see if it matches the target
for ( elem in t )
2011-07-25 10:06:39 -04:00
{
2012-02-08 11:54:46 -05:00
// Fire target callback when event bubbles from target
2012-10-04 13:25:09 -04:00
if ( e . target == t [ elem ] )
2011-06-29 11:34:05 -04:00
{
2012-02-08 11:54:46 -05:00
// Trigger the event callback
callback . call ( t [ elem ] , e ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Stop event propegation
e . stopPropagation ( ) ;
2011-06-29 11:34:05 -04:00
}
2011-10-24 12:35:48 -04:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
} , true ) ;
} ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// --------------------------------------------------------------------------
/ * *
* Event Listener module
*
* @ namespace
* @ name event
* @ memberOf $ _
* /
e = {
/ * *
* Adds an event that returns a callback when triggered on the selected
* event and selector
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ memberOf $ _ . event
* @ name add
* @ function
* @ example Eg . $ _ ( "#selector" ) . event . add ( "click" , do _something ( ) ) ;
* @ param string event
* @ param function callback
* /
add : function ( event , callback )
{
$ _ . each ( function ( e ) {
_add _remove ( e , event , callback , true ) ;
} ) ;
2011-10-24 12:35:48 -04:00
} ,
2011-11-01 18:56:27 -04:00
/ * *
2012-02-08 11:54:46 -05:00
* Removes an event bound the the specified selector , event type , and callback
2011-11-01 18:56:27 -04:00
*
2012-02-08 11:54:46 -05:00
* @ memberOf $ _ . event
* @ name remove
2011-11-01 18:56:27 -04:00
* @ function
2012-02-08 11:54:46 -05:00
* @ example Eg . $ _ ( "#selector" ) . event . remove ( "click" , do _something ( ) ) ;
* @ param string event
* @ param string callback
2011-11-01 18:56:27 -04:00
* /
2012-02-08 11:54:46 -05:00
remove : function ( event , callback )
2011-10-24 12:35:48 -04:00
{
2012-02-08 11:54:46 -05:00
$ _ . each ( function ( e ) {
_add _remove ( e , event , callback , false ) ;
} ) ;
} ,
2012-03-29 12:05:11 -04:00
/ * *
2012-02-08 11:54:46 -05:00
* Binds a persistent event to the document
*
* @ memberOf $ _ . event
* @ name live
* @ function
* @ example Eg . $ _ . event . live ( ".button" , "click" , do _something ( ) ) ;
* @ param string target
* @ param string event
* @ param function callback
* /
live : function ( target , event , callback )
{
_attach _delegate ( document . documentElement , target , event , callback ) ;
} ,
2012-03-29 12:05:11 -04:00
/ * *
2012-02-08 11:54:46 -05:00
* Binds an event to a parent object
*
* @ memberOf $ _ . event
* @ name delegate
* @ function
* @ example Eg . $ _ ( "#parent" ) . delegate ( ".button" , "click" , do _something ( ) ) ;
* @ param string target
* @ param string event _type
* @ param function callback
* /
delegate : function ( target , event , callback )
{
$ _ . each ( function ( e ) {
_attach _delegate ( e , target , event , callback ) ;
} ) ;
}
} ;
2011-10-24 19:18:22 -04:00
2012-02-08 11:54:46 -05:00
$ _ . ext ( 'event' , e ) ;
2011-10-24 19:18:22 -04:00
2012-04-05 18:39:10 -04:00
2012-02-08 11:54:46 -05:00
2011-10-24 12:35:48 -04:00
// --------------------------------------------------------------------------
2011-07-25 10:06:39 -04:00
2011-10-24 12:35:48 -04:00
/ * *
2012-03-29 12:05:11 -04:00
* Store
*
2012-02-08 11:54:46 -05:00
* Wrapper for local / sessionstorage
2011-10-24 12:35:48 -04:00
* /
2012-03-29 12:05:11 -04:00
2012-04-05 18:39:10 -04:00
2012-02-08 11:54:46 -05:00
//Shortcuts for wrapper
var l = localStorage ,
s = sessionStorage ;
/ * *
* Wrapper for localstorage / sessionstorage data serialization .
* Each method has a boolean parameter , that when set as true switches the method
* to use sessionStorage rather than the default localStorage .
*
* @ name store
* @ namespace
* @ memberOf $ _
* /
2012-03-29 12:05:11 -04:00
var store = {
2011-11-01 18:56:27 -04:00
/ * *
2012-03-29 12:05:11 -04:00
* Retrieves and deserializes a value from localstorage ,
2012-02-08 11:54:46 -05:00
* based on the specified key
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ param string key
* @ param bool session
* @ name get
* @ memberOf $ _ . store
* @ function
* @ return object
* @ type object
2011-11-01 18:56:27 -04:00
* /
2012-02-08 11:54:46 -05:00
get : function ( key , sess )
2011-07-25 10:06:39 -04:00
{
2012-02-08 11:54:46 -05:00
var val = ( sess ) ? s . getItem ( key ) : l . getItem ( key ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return JSON . parse ( val ) ;
} ,
2011-11-01 18:56:27 -04:00
/ * *
2012-02-08 11:54:46 -05:00
* Puts a value into localstorage at the specified key ,
* and JSON - encodes the value if not a string
*
* @ param string key
* @ param mixed value
* @ param bool session
* @ name set
* @ memberOf $ _ . store
* @ function
2011-11-01 18:56:27 -04:00
* /
2012-02-08 11:54:46 -05:00
set : function ( key , value , sess )
2011-10-24 12:35:48 -04:00
{
2012-02-08 11:54:46 -05:00
// Localstorage generally only accepts strings
2012-03-29 12:05:11 -04:00
value = JSON . stringify ( value ) ;
2012-02-08 11:54:46 -05:00
( sess ) ? s . setItem ( key , value ) : l . setItem ( key , value ) ;
} ,
/ * *
* Removes the specified item from storage
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ param string key
* @ param bool session
* @ name remove
* @ memberOf $ _ . store
* @ function
* /
remove : function ( key , sess )
{
( sess ) ? s . removeItem ( key ) : l . removeItem ( key ) ;
} ,
/ * *
* Returns an object of all the raw values in storage
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ param bool session
* @ name getAll
* @ memberOf $ _ . store
* @ function
* @ return object
* @ type object
* /
getAll : function ( sess )
{
var i ,
len ,
data = { } ,
k ,
o ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Reference to session/localstorage
o = ( sess ) ? l : s ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
len = o . length ;
for ( i = 0 ; i < len ; i ++ )
2011-11-01 18:56:27 -04:00
{
2012-02-08 11:54:46 -05:00
k = o . key ( i ) ;
data [ k ] = o . getItem ( k ) ;
2011-11-01 18:56:27 -04:00
}
2012-02-08 11:54:46 -05:00
return data ;
} ,
/ * *
* Removes all values from the same domain storage
*
* @ param bool session
* @ name clear
* @ memberOf $ _ . store
* @ function
* /
clear : function ( sess )
{
( sess ) ? s . clear ( ) : l . clear ( ) ;
}
} ;
$ _ . ext ( 'store' , store ) ;
2012-04-05 18:39:10 -04:00
2012-02-08 11:54:46 -05:00
// --------------------------------------------------------------------------
/ * *
* Util Object
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* Various object and string manipulation functions
* Note : these are based on similar phpjs functions : http : //phpjs.org
2011-11-15 12:03:12 -05:00
* /
2012-02-08 11:54:46 -05:00
2012-04-05 18:39:10 -04:00
2012-03-29 12:05:11 -04:00
var reverse _key _sort = function ( o )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
//Define some variables
var keys = [ ] ,
num _keys = 0 ,
new _o = { } ,
i ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Extract the keys
keys = u . object _keys ( o ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Sort the keys
2012-03-29 12:05:11 -04:00
keys . sort ( function ( b , a ) {
2012-02-08 11:54:46 -05:00
var aFloat = parseFloat ( a ) ,
bFloat = parseFloat ( b ) ,
aNumeric = aFloat + '' === a ,
bNumeric = bFloat + '' === b ;
2012-03-29 12:05:11 -04:00
if ( aNumeric && bNumeric )
2012-02-08 11:54:46 -05:00
{
return aFloat > bFloat ? 1 : aFloat < bFloat ? - 1 : 0 ;
2012-03-29 12:05:11 -04:00
}
else if ( aNumeric && ! bNumeric )
2012-02-08 11:54:46 -05:00
{
return 1 ;
2012-03-29 12:05:11 -04:00
}
else if ( ! aNumeric && bNumeric )
2012-02-08 11:54:46 -05:00
{
return - 1 ;
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return a > b ? 1 : a < b ? - 1 : 0 ;
} ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// cache object/array size
num _keys = keys . length ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Recreate the object/array
for ( i = 0 ; i < num _keys ; i ++ )
{
new _o [ keys [ i ] ] = o [ keys [ i ] ] ;
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return new _o ;
} ,
2012-03-29 12:05:11 -04:00
2011-11-15 12:03:12 -05:00
/ * *
2012-02-08 11:54:46 -05:00
* String and object manipulation utilities
2012-03-29 12:05:11 -04:00
*
2011-11-15 12:03:12 -05:00
* @ namespace
2012-02-08 11:54:46 -05:00
* @ name util
2011-11-15 12:03:12 -05:00
* @ memberOf $ _
* /
2012-02-08 11:54:46 -05:00
u = {
2011-11-15 12:03:12 -05:00
/ * *
2012-02-08 11:54:46 -05:00
* Retrieve the keys , or member names of an object
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ name object _keys
* @ memberOf $ _ . util
2011-11-15 12:03:12 -05:00
* @ function
2012-02-08 11:54:46 -05:00
* @ param object
* @ return array
* @ type array
2011-11-15 12:03:12 -05:00
* /
2012-02-08 11:54:46 -05:00
object _keys : function ( o )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
var keys = [ ] ,
k ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
for ( k in o )
{
if ( o . hasOwnProperty ( k ) )
{
keys . push ( k ) ;
}
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return keys ;
} ,
/ * *
* Retrieves the values of an object , and returns
* them as an array
*
* @ name object _values
* @ memberOf $ _ . util
* @ function
* @ param object
* @ return array
* @ type array
* /
object _values : function ( o )
{
var vals = [ ] ,
prop ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
for ( prop in o )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
vals . push ( o [ prop ] ) ;
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return vals ;
2011-11-15 12:03:12 -05:00
} ,
/ * *
2012-03-29 12:05:11 -04:00
* Creates an object , with the property names of the first array ,
* and the values of the second . If objects are passed , the values
* of the object are used . If the arrays or objects passed are
2012-02-08 11:54:46 -05:00
* not the same size , the function will return false .
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ name array _combine
* @ memberOf $ _ . util
2011-11-15 12:03:12 -05:00
* @ function
2012-02-08 11:54:46 -05:00
* @ param array / object keys
* @ param array / object vals
* @ return object
* @ type object
2011-11-15 12:03:12 -05:00
* /
2012-02-08 11:54:46 -05:00
array _combine : function ( keys , vals )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
var new _object = { } ,
num _keys ,
i = 0 ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Extract the keys or values if needed
if ( $ _ . type ( keys ) !== "array" )
{
keys = this . object _values ( keys ) ;
}
if ( $ _ . type ( vals ) !== "array" )
{
vals = this . object _values ( vals ) ;
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// cache the number of keys
num _keys = keys . length ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
if ( num _keys !== vals . length )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
return false ;
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Create and return the new object
for ( i = 0 ; i < num _keys ; i ++ )
{
new _object [ keys [ i ] ] = vals [ i ] ;
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return new _object ;
} ,
/ * *
* Combines two or more objects / arrays . If the keys are numeric , the outputted
* object will have re - indexed keys . If a key / value pair exists in both objects ,
2012-03-29 12:05:11 -04:00
* indentical values will be droped , but if a key exists with a different value ,
2012-02-08 11:54:46 -05:00
* with the same key , the value in the second array will replace the value in the
* first
2012-03-29 12:05:11 -04:00
*
2012-02-08 11:54:46 -05:00
* @ name object _merge
* @ memberOf $ _ . util
* @ function
* @ param object [ as many as you wish to combine ]
* @ type object
* @ return object
* /
object _merge : function ( )
{
var args = Array . prototype . slice . call ( arguments ) ,
arg _len = args . length ,
new _obj = { } ,
arg ,
iarg _len = 0 ,
i ,
j ,
x ,
is _array = true ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Check for an array in the arguments
for ( i = 0 ; i < arg _len ; i ++ )
{
if ( $ _ . type ( args [ i ] ) !== "array" )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
is _array = false ;
break ;
2011-11-15 12:03:12 -05:00
}
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// If all the arguments are javascript arrays
if ( is _array )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
new _obj = [ ] ;
// Let javascript do all the work!
for ( i = 0 ; i < arg _len ; i ++ )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
new _obj = new _obj . contact ( args [ i ] ) ;
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// Return early
return new _obj ;
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// No, there's at least one object
for ( i = 0 , x = 0 ; i < arg _len ; i ++ )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
arg = args [ i ] ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
// If the argument is an array, add the array items as
// numeric object properties
if ( $ _ . type ( arg ) == "array" )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
for ( j = 0 , iarg _len = arg . length ; j < iarg _len ; j ++ )
{
new _obj [ x ++ ] = arg [ j ] ;
}
2011-11-15 12:03:12 -05:00
}
2012-02-08 11:54:46 -05:00
else
{
for ( j in arg )
{
if ( arg . hasOwnProperty ( j ) )
{
// If the key is numeric, add the property with
// a numeric key
if ( parseInt ( j , 10 ) + '' === j )
{
new _obj [ x ++ ] = arg [ j ] ;
}
else
{
new _obj [ j ] = arg [ j ] ;
2012-03-29 12:05:11 -04:00
}
2012-02-08 11:54:46 -05:00
}
}
2012-03-29 12:05:11 -04:00
}
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
return new _obj ;
2011-11-15 12:03:12 -05:00
} ,
2012-02-08 11:54:46 -05:00
/ * *
2012-03-29 12:05:11 -04:00
* Replaces sections of strings in a greedy fashion ,
2012-02-08 11:54:46 -05:00
* starting with the longest replace pairs first . Accepts
* one replace pair as two parameters , or an object , with
* from => to replacements as key / value pairs
2011-11-15 12:03:12 -05:00
*
2012-02-08 11:54:46 -05:00
* @ name str _trans
* @ memberOf $ _ . util
2011-11-15 12:03:12 -05:00
* @ function
2012-02-08 11:54:46 -05:00
* @ param string input _string
* @ param mixed from ( string ) / replace pairs ( object )
* @ param [ string ]
* @ return string
* @ type string
2011-11-15 12:03:12 -05:00
* /
2012-02-08 11:54:46 -05:00
str _trans : function ( str , from , to )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
var froms = [ ] ,
tos = [ ] ,
ret = '' ,
match = false ,
from _len = 0 ,
str _len = 0 ,
to _len = 0 ,
to _is _str = '' ,
from _is _str = '' ,
strx = '' ,
strw = '' ,
stry = '' ,
from _strx = '' ,
new _str = '' ,
f ,
i ,
j ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Replace pairs? add them to the internal arrays
if ( typeof from === 'object' )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
// Sort the keys in descending order for better
// replacement functionality
from = reverse _key _sort ( from ) ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
for ( f in from )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
if ( from . hasOwnProperty ( f ) )
{
froms . push ( f ) ;
tos . push ( from [ f ] ) ;
}
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
from = froms ;
to = tos ;
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Go through the string, and replace characters as needed
str _len = str . length ;
from _len = from . length ;
to _len = to . length ;
to _is _str = typeof to === 'string' ;
from _is _str = typeof from === 'string' ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
for ( i = 0 ; i < str _len ; i ++ )
{
match = false ;
if ( from _is _str )
2011-11-15 12:03:12 -05:00
{
2012-02-08 11:54:46 -05:00
strw = str . charAt ( i - 1 ) ;
strx = str . charAt ( i ) ;
stry = str . charAt ( i + 1 ) ;
for ( j = 0 ; j < from _len ; j ++ )
{
if ( strx == from . charAt ( j ) )
{
match = true ;
break ;
}
}
2011-11-15 12:03:12 -05:00
}
2012-02-08 11:54:46 -05:00
else
{
for ( j = 0 ; j < from _len ; j ++ )
{
if ( str . substr ( i , from [ j ] . length ) == from [ j ] )
{
match = true ;
2012-03-29 12:05:11 -04:00
2012-02-08 11:54:46 -05:00
//Go past the current match
i = ( i + from [ j ] . length ) - 1 ;
break ;
}
}
}
if ( match )
{
new _str += ( to _is _str ) ? to . charAt ( j ) : to [ j ] ;
}
else
{
new _str += str . charAt ( i ) ;
}
}
return new _str ;
2012-03-29 12:05:11 -04:00
2011-11-15 12:03:12 -05:00
}
2012-03-29 12:05:11 -04:00
2011-11-15 12:03:12 -05:00
} ;
2012-02-08 11:54:46 -05:00
//Add it to the $_ object
$ _ . ext ( 'util' , u ) ;
2012-04-05 18:39:10 -04:00
} ( $ _ ) ) ;