Initial commit

botanjs/src/System/Cycle/Trigger.js

@@ -0,0 +1,75 @@
+(function(){
+	var ns = __namespace( "System.Cycle.Trigger" );
+
+	/** @type {System.Cycle} */
+	var Cycle = __import( "System.Cycle" );
+
+	// trigger list
+	var tList = [];
+	var stepperId = -1;
+
+	var stepper = function( args )
+	{
+		var thisTime = new Date().getTime();
+		for ( var i in tList )
+		{
+			var f = tList[i];
+			if( f && thisTime > f[2] )
+			{
+				try
+				{
+					if( f[0]() )
+					{
+						f[1]();
+						delete tList[i];
+					}
+					else f[2] = thisTime + f[3];
+				}
+				catch(e)
+				{
+					debug.Error(e);
+					delete tList[i];
+				}
+			}
+		}
+	};
+
+	var registerTrigger = function ( trigger, handler, peekInt )
+	{
+		tList[ tList.length ] = [ trigger, handler, new Date().getTime() + peekInt, peekInt ]
+	};
+
+	var heightTrigger = function ( __element, value, handler )
+	{
+		var k = function () {
+			return ( this.a.clientHeight == this.b );
+		}.bind({ a: __element, b: value });
+
+		registerTrigger( k, handler, 50 );
+	};
+
+	var transitionTrigger = function (__style, value, handler)
+	{
+		var k = function ()
+		{
+			return ( this.a.transition == this.b );
+		}.bind({a: __style, b: value });
+		registerTrigger( k, handler, 50 );
+	};
+
+	var regTick = function( e )
+	{
+		if( stepperId < 0 )
+		{
+			stepperId = Cycle.TICK.putStepper( stepper );
+		}
+	};
+
+	ns.addEventListener( "NS_IMPORT", regTick );
+
+	ns[ NS_EXPORT ]( EX_FUNC, "register", registerTrigger );
+	ns[ NS_EXPORT ]( EX_FUNC, "transition", transitionTrigger );
+	ns[ NS_EXPORT ]( EX_FUNC, "height", heightTrigger );
+
+	ns[ NS_TRIGGER ]( TGR_IMPORT, regTick );
+})();

botanjs/src/System/Cycle/_this.js

@@ -0,0 +1,108 @@
+(function(){
+	var ns = __namespace( "System.Cycle" );
+
+	/** @type {System.Tick} */
+	var utils                   = __import( "System.utils" );
+	/** @type {System.Tick} */
+	var Tick                    = __import( "System.Tick" );
+	/** @type {System.Debug} */
+	var debug                   = __import( "System.Debug" );
+
+	var tList = [];
+
+	var stepper = function()
+	{
+		var thisTime = new Date().getTime();
+		// 0: Callback
+		// 1: scheduled run time
+		// 2: Permanent
+		// ( 3: id )
+		// 4: interval
+		for ( var i in tList )
+		{
+			var f = tList[i];
+			if( f && thisTime > f[1] )
+			{
+				try
+				{
+					f[0]();
+				}
+				catch(e)
+				{
+					debug.Error(e);
+					delete tList[i];
+					continue;
+				}
+
+				if( f[2] )
+				{
+					delete tList[i];
+				}
+				else
+				{
+					f[1] = thisTime + f[4];
+				}
+			}
+		}
+	};
+
+	// Should bind "func" before register
+	var registerDelay = function (func, milliSec)
+	{
+		tList[ tList.length ] = [ func, new Date().getTime() + milliSec, true ];
+	};
+
+	var registerPermanentTicker = function ( id, func, interval )
+	{
+		for ( var i in tList )
+		{
+			if( tList[i][3] == id )
+				return false;
+		}
+
+		tList[ tList.length ] = [ func, new Date().getTime() + interval, false, id, interval ];
+	};
+
+	var deletePermanentTicker = function ( id )
+	{
+		// 3: id
+		for ( var i in tList )
+		{
+			if( tList[i][3] == id )
+				delete tList[i];
+		}
+	};
+
+	var next = function( func )
+	{
+		tList[ tList.length ] = [ func, 0, true ];
+	};
+
+	var ourTick = new Tick();
+	ourTick.putStepper( stepper );
+
+	var gTickStart = function( e )
+	{
+		e.target.removeEventListener( "NS_IMPORT", gTickStart );
+
+		var TICK = __import( "System.Cycle.TICK", true );
+
+		if( TICK != ourTick && TICK.started )
+		{
+			debug.Info( "[System.Cycle] Global Tick exists" );
+			ourTick = null;
+			return;
+		}
+
+		debug.Info( "[System.Cycle] Creating global Tick" );
+		ourTick.start();
+	};
+
+	ns.addEventListener( "NS_IMPORT", gTickStart );
+
+	ns[ NS_EXPORT ]( EX_FUNC, "next", next );
+	ns[ NS_EXPORT ]( EX_FUNC, "delay", registerDelay );
+	ns[ NS_EXPORT ]( EX_FUNC, "perma", registerPermanentTicker );
+	ns[ NS_EXPORT ]( EX_FUNC, "permaRemove", deletePermanentTicker );
+	ns[ NS_EXPORT ]( EX_READONLY_GETTER, "TICK", function(){ return ourTick; } );
+})();

botanjs/src/System/Debug.js

@@ -0,0 +1,46 @@
+(function(){
+	var ns = __namespace( "System.Debug" );
+	/** @type {System.Log} */
+	var Log = __import( "System.Log" );
+	/** @type {System.Global} */
+	var _global = __import( "System.Global" );
+
+	var st_info = _global.debug;
+	var st_error = true;
+
+	var Error = function( e )
+	{
+		if( st_error )
+		Log.writeLine( e.name + "\n\t" + e.message + "\n\t" + e.stack, Log.ERROR );
+	};
+
+	var Info = function(e)
+	{
+		if( st_info )
+		Log.writeLine( e, Log.INFO );
+	};
+
+	var turnOff = function( what )
+	{
+		if( what == "info" ) st_info = false;
+		else if( what == "error" ) st_error = false;
+	};
+
+	var turnOn = function( what )
+	{
+		if( what == "info" ) st_info = true;
+		else if( what == "error" ) st_error = true;
+	};
+
+	/* {{{ Root log override */
+	BotanJS.log.write = Info;
+
+	while( !BotanJS.log.end() )
+		Info( BotanJS.log.read() );
+	/* End Root log override }}}*/
+
+	ns[ NS_EXPORT ]( EX_FUNC, "Error", Error );
+	ns[ NS_EXPORT ]( EX_FUNC, "Info", Info );
+	ns[ NS_EXPORT ]( EX_FUNC, "turnOff", turnOff );
+	ns[ NS_EXPORT ]( EX_FUNC, "turnOn", turnOn );
+})();

botanjs/src/System/Global.js

@@ -0,0 +1,16 @@
+(function(){
+	var ns = __namespace( "System.Global" );
+
+	var debug = function()
+	{
+		return window[ "debugEnv" ] && window[ "debugEnv" ];
+	};
+
+	// for IE < 10
+	var IE = Boolean( document[ "all" ] );
+	var ALLOWED_ORIGINS = window[ "allowed_origins" ] || [];
+
+	ns[ NS_EXPORT ]( EX_READONLY_GETTER, "debug", debug );
+	ns[ NS_EXPORT ]( EX_CONST, "IE", IE );
+	ns[ NS_EXPORT ]( EX_CONST, "ALLOWED_ORIGINS", ALLOWED_ORIGINS );
+})();

botanjs/src/System/Log.js

@@ -0,0 +1,46 @@
+(function(){
+	var ns = __namespace( "System.Log" );
+	var handler = [];
+
+	var SYSTEM = 1;
+	var INFO = 16;
+	var ERROR = 32;
+
+	var writeLine = function ( mesg, type )
+	{
+		type = ( type === undefined ) ? INFO : type;
+
+		var handled = false;
+		for( var i in handler )
+		{
+			handler[i]( mesg, type );
+			handled = true;
+		}
+
+		if( !handled
+			&& window[ "console" ]
+			&& console.log
+		) console.log( mesg );
+	};
+
+	var registerHandler = function( func )
+	{
+		var index = -1;
+		handler[ index = handler.length ] = func;
+
+		return index;
+	};
+
+	var removeHandler = function( index )
+	{
+		delete handler[ index ];
+	};
+
+	ns[ NS_EXPORT ]( EX_FUNC, "writeLine", writeLine );
+	ns[ NS_EXPORT ]( EX_FUNC, "registerHandler", registerHandler );
+	ns[ NS_EXPORT ]( EX_FUNC, "removeHandler", removeHandler );
+
+	ns[ NS_EXPORT ]( EX_CONST, "INFO", INFO );
+	ns[ NS_EXPORT ]( EX_CONST, "ERROR", ERROR );
+	ns[ NS_EXPORT ]( EX_CONST, "SYSTEM", SYSTEM );
+})();

botanjs/src/System/Net/ClassLoader.js

@@ -0,0 +1,75 @@
+(function(){
+	var ns = __namespace( "System.Net" );
+	var className = "ClassLoader";
+
+	/** @type {System.utils} */
+	var utils                        = __import( "System.utils" );
+	/** @type {System.utils.IKey} */
+	var IKey                         = __import( "System.utils.IKey" );
+	/** @type {Dandelion} */
+	var Dand                         = __import( "Dandelion" );
+
+	var loadFile = function ( sapi, request, mode )
+	{
+		var head = Dand.tag( "head" )[0];
+
+		// Add css
+		head.appendChild(
+			Dand.wrapna(
+				"link"
+				, IKey.quickDef(
+					"rel", "stylesheet"
+					, "type", "text/css"
+					, "href", sapi + mode + "css/" + request
+				)
+			)
+		);
+
+		// Add js
+		head.appendChild(
+			Dand.wrapna(
+				"script"
+				, IKey.quickDef(
+					"type", "text/javascript"
+					, "src",  sapi + mode + "js/" + request
+				)
+			)
+		);
+
+	};
+
+	var Loader = function( sapi, mode )
+	{
+		mode = ( mode === undefined ) ? "o" : mode;
+
+		this.load = function( classes, handler )
+		{
+			if( !classes.join ) classes = [ classes ];
+
+			var excludes = BotanJS.getDef();
+			// Excludes
+			utils.objMap( excludes , function( v ) { return "-" + v; } );
+
+			var loadc = null;
+			var onLoad = function( e )
+			{
+				if( classes.indexOf( e.data.name ) < 0 ) return;
+				handler( e.data.name );
+			};
+
+			var sp = mode ? { 'o': '/', 'r': '/' }[ mode ] : ',';
+
+			loadFile(
+				sapi
+				, classes.join( sp ) + sp + excludes.join( sp )
+				, mode
+			);
+
+			BotanJS.addEventListener( "NS_INIT", onLoad );
+			BotanJS.addEventListener( "NS_EXPORT", onLoad );
+		};
+	};
+
+	ns[ NS_EXPORT ]( EX_CLASS, "ClassLoader", Loader );
+})();
+

botanjs/src/System/Net/_this.js

@@ -0,0 +1,141 @@
+(function(){
+	var ns                              = __namespace( "System.Net" );
+	/** @type {System.Debug} */
+	var debug                           = __import( "System.Debug" );
+	/** @type {Dandelion.IDOMObject} */
+	var IDOMObject                      = __import( "Dandelion.IDOMObject" );
+
+	// Handles all http transfers
+	var getData = function (uri, handler, failedHandler)
+	{
+		var request = new XMLHttpRequest();
+		debug.Info("[Net] GET: " + uri);
+		request.onreadystatechange = function()
+		{
+			/*
+				0: request not initialized 
+				1: server connection established
+				2: request received 
+				3: processing request 
+				4: request finished and response is ready
+			*/
+			if(request.readyState == 2)
+			{
+				debug.Info("[Net] GET R2:" + uri);
+			}
+			else if (request.readyState == 4)
+			{
+				debug.Info("[Net] GET R4:" + uri);
+				if (request.status == 200)
+				{
+					try
+					{
+						handler(request.responseText);
+					}
+					catch(e)
+					{
+						debug.Error(e);
+						failedHandler(null);
+					}
+				}
+				else
+				{
+					debug.Info("[Net] Status: " + request.status.toString());
+					debug.Info(request.responseText);
+					failedHandler && failedHandler(null);
+				}
+			}
+		}
+		request.open("GET", uri, true);
+		request.send();
+	};
+
+	var postFile = function (uri, data, handlers)
+	{
+		var request = new XMLHttpRequest()
+			, generalExchange = new IDOMObject( request )
+			, uploadExchange = new IDOMObject( request.upload )
+		;
+
+		if ( uploadExchange ) {
+			handlers.progress && uploadExchange.addEventListener("Progress", handlers.progress);
+			handlers.failed && uploadExchange.addEventListener("Error", handlers.failed);
+		}
+
+		generalExchange.addEventListener("ReadyStateChange", function(e) {
+			if ( 4 == this.readyState ) {
+				handlers.complete && handlers.complete(request.responseText);
+			}
+		});
+
+		request.open("POST", uri, true);
+		// request.setRequestHeader("Content-Type", "multipart/form-data");
+		request.send(data);
+	};
+
+	var postData = function (uri, data, handler, failedHandler)
+	{
+		var request = new XMLHttpRequest();
+		// compile post string
+		data = compilePostData(data);
+		debug.Info("[Net] PostString: " + data);
+		request.onreadystatechange = function()
+		{
+			/*
+				0: request not initialized 
+				1: server connection established
+				2: request received 
+				3: processing request 
+				4: request finished and response is ready
+			*/
+			if(request.readyState == 2)
+			{
+				debug.Info("[Net] POST R2:" + uri);
+			}
+			else if (request.readyState == 4)
+			{
+				debug.Info("[Net] POST R4:" + uri);
+				if (request.status == 200)
+				{
+					try
+					{
+						var obj = JSON.parse(request.responseText);
+						obj.status ? handler(obj): failedHandler(obj);
+					}
+					catch(e)
+					{
+						debug.Error(e);
+						failedHandler(null);
+					}
+				}
+				else
+				{
+					debug.Info("[Net] Status: " + request.status.toString());
+					debug.Info(request.responseText);
+					failedHandler(null);
+				}
+			}
+		};
+
+		request.open( "POST", uri );
+		request.setRequestHeader( "Content-Type", "application/x-www-form-urlencoded" );
+		request.send( data );
+	};
+
+	var compilePostData = function (obj)
+	{
+		var postdata = "timestamp=" + new Date().getTime();
+		for(var name in obj)
+		{
+			postdata += "&" + name + "=" + encodeURIComponent(obj[name]);
+		}
+
+		return postdata;
+	};
+
+	ns[ NS_EXPORT ]( EX_FUNC, "getData", getData );
+	ns[ NS_EXPORT ]( EX_FUNC, "postData", postData );
+	ns[ NS_EXPORT ]( EX_FUNC, "postFile", postFile );
+	// ns[ NS_EXPORT ]( EX_FUNC, "compilePostData", compilePostData );
+})();
+

botanjs/src/System/Policy/_this.js

@@ -0,0 +1,13 @@
+(function(){
+	var ns = __namespace( "System.Policy" );
+
+	/** @type {System.Global} */
+	var Global = __import( "System.Global" );
+
+	var isOriginAllowed = function( origin )
+	{
+		return -1 < Global.ALLOWED_ORIGINS.indexOf( origin );
+	};
+
+	ns[ NS_EXPORT ]( EX_FUNC, "isOriginAllowed", isOriginAllowed );
+})();

botanjs/src/System/Tick.js

@@ -0,0 +1,50 @@
+(function(){
+	var ns = __namespace( "System" );
+
+	var Tick = function()
+	{
+		// cycle counter
+		var nc = 0;
+		this.__started = false;
+
+		this.loop = function()
+		{
+			for( var i in this.steppers )
+				this.steppers[i]();
+			nc ++;
+		};
+
+		__readOnly( this, "count", function() { return nc; } );
+	};
+
+	Tick.prototype.putStepper = function( stepperCallback )
+	{
+		var l = this.steppers.length;
+		this.steppers[l] = stepperCallback;
+		return l;
+	};
+
+	Tick.prototype.start = function()
+	{
+		if( !this.__started )
+		{
+			this.id = setInterval( this.loop.bind( this ), 0 );
+			this.__started = true;
+		}
+	};
+
+	Tick.prototype.stop = function()
+	{
+		if( this.__started )
+		{
+			this.__started = false;
+			clearInterval( this.id );
+		}
+	};
+
+	Tick.prototype.steppers = [];
+
+	__readOnly( Tick.prototype, "started", function() { return this.__started; } );
+
+	ns[ NS_EXPORT ]( EX_CLASS, "Tick", Tick );
+})();

botanjs/src/System/_this.js

@@ -0,0 +1,3 @@
+(function(){
+	var ns = __namespace( "System" )
+})();

botanjs/src/System/utils/DataKey.js

@@ -0,0 +1,17 @@
+(function(){
+	var ns = __namespace( "System.utils" );
+	var IKey = ns[ NS_INVOKE ]( "IKey" );
+	// Data key
+	var DataKey = function ( name, value )
+	{
+		IKey.call(
+			this
+			, "data-" + name
+			, value ? encodeURIComponent( String( value ) ) : ""
+		);
+	};
+
+	__extends( DataKey, IKey );
+
+	ns[ NS_EXPORT ]( EX_CLASS, "DataKey", DataKey );
+})();

botanjs/src/System/utils/EventKey.js

@@ -0,0 +1,19 @@
+(function(){
+	var ns = __namespace( "System.utils" );
+	var IKey = ns[ NS_INVOKE ]( "IKey" );
+	// Event key
+	var EventKey = function ( eventType, eventHandler )
+	{
+		IKey.call( this, eventType, eventHandler );
+
+		this.type = eventType.toLowerCase();
+		this.handler = eventHandler;
+	}
+
+	__extends( EventKey, IKey );
+
+	EventKey.prototype.type = "";
+	EventKey.prototype.handler = null;
+
+	ns[ NS_EXPORT ]( EX_CLASS, "EventKey", EventKey );
+})();

botanjs/src/System/utils/IKey.js

@@ -0,0 +1,49 @@
+(function(){
+	var ns = __namespace( "System.utils" );
+	var ClassName = "IKey";
+
+	////// Class IKey
+	var IKey = function (name, value)
+	{
+		if ( name && ( typeof name != "string" ) ) return;
+		this.keyName = name;
+
+		if( value instanceof IKey )
+		{
+			this.keyValue = value;
+		}
+		else
+		{
+			this.keyValue = (value != undefined) ? String(value) : "";
+		}
+
+		this["keyName"] = this.keyName;
+		this["keyValue"] = this.keyValue;
+	};
+
+	IKey.prototype.keyName = "";
+	IKey.prototype.keyValue = "";
+
+	var quickDef = function()
+	{
+		var l = arguments.length;
+
+		if( l % 2 != 0 )
+		{
+			ns[ NS_THROW ]( "Invalid Definition Count", ClassName );
+		}
+
+		var keys = [];
+		for( var i = 0; i < l; i += 2 )
+		{
+			keys[ keys.length ] = new IKey( arguments[i], arguments[ i + 1 ] );
+		}
+
+		return keys;
+	};
+
+	__static_method( IKey, "quickDef", quickDef );
+
+	ns[ NS_EXPORT ]( EX_CLASS, "IKey", IKey );
+
+})();

botanjs/src/System/utils/Perf.js

@@ -0,0 +1,49 @@
+(function(){
+	// Performance Functions
+	var ns = __namespace( "System.utils.Perf" );
+
+	/** {{{ Fast UUID generator, RFC4122 version 4 compliant.
+	 * author: Jeff Ward (jcward.com).
+	 * license: MIT license
+	 * link: http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
+	 **/
+	var lut = [];
+	for ( var i=0; i < 256; i++ )
+	{
+		lut[i] = ( i < 16 ? '0' : '' ) + ( i ).toString(16);
+	}
+
+	var UUID = function()
+	{
+		var d0 = Math.random()*0xffffffff|0;
+		var d1 = Math.random()*0xffffffff|0;
+		var d2 = Math.random()*0xffffffff|0;
+		var d3 = Math.random()*0xffffffff|0;
+		return lut[d0&0xff]+lut[d0>>8&0xff]+lut[d0>>16&0xff]+lut[d0>>24&0xff]+'-'+
+			lut[d1&0xff]+lut[d1>>8&0xff]+'-'+lut[d1>>16&0x0f|0x40]+lut[d1>>24&0xff]+'-'+
+			lut[d2&0x3f|0x80]+lut[d2>>8&0xff]+'-'+lut[d2>>16&0xff]+lut[d2>>24&0xff]+
+			lut[d3&0xff]+lut[d3>>8&0xff]+lut[d3>>16&0xff]+lut[d3>>24&0xff];
+	};
+	/* }}}*/
+
+	// Reverse an array using XOR swap
+	var Array_Reverse = function( array )
+	{
+		var i = null;
+		var l = array.length;
+		var r = null;
+		for (i = 0, r = l - 1; i < r; i += 1, r -= 1)
+		{
+			var left = array[i];
+			var right = array[r];
+			left ^= right;
+			right ^= left;
+			left ^= right;
+			array[i] = left;
+			array[r] = right;
+		}
+	};
+
+	ns[ NS_EXPORT ]( EX_READONLY_GETTER, "uuid", UUID );
+	ns[ NS_EXPORT ]( EX_FUNC, "ArrayReverse", Array_Reverse );
+})();

botanjs/src/System/utils/_this.js

@@ -0,0 +1,41 @@
+(function(){
+	var ns = __namespace( "System.utils" );
+
+	// Get prop from obj if obj.<prop> is <type>
+	var objGetProp = function ( obj, prop, type )
+	{
+		if(obj && obj[prop])
+		{
+			var t = obj[prop].constructor.toString().match(/function ([^\(]+)/);
+			if(t && t.length == 2 && t[1].toUpperCase() == type.toUpperCase())
+			{
+				return obj[prop];
+			}
+		}
+		return null;
+	};
+
+	var objSearch = function ( obj, cond, prop )
+	{
+		for( var i in obj )
+		{
+			if( cond( obj[i] ) )
+			{
+				return obj[i][prop] || obj[i];
+			}
+		}
+		return null;
+	};
+
+	var objMap = function( obj, callback )
+	{
+		for( var i in obj )
+		{
+			obj[i] = callback( obj[i] );
+		}
+	};
+
+	ns[ NS_EXPORT ]( EX_FUNC, "objGetProp", objGetProp );
+	ns[ NS_EXPORT ]( EX_FUNC, "objSearch", objSearch );
+	ns[ NS_EXPORT ]( EX_FUNC, "objMap", objMap );
+})();