@datagrok/helm 2.3.2 → 2.3.4

package/vendor/dojo-1.10.10/dojox/lang/utils.js.uncompressed.js

@@ -0,0 +1,121 @@
+define("dojox/lang/utils", ["..", "dojo/_base/lang"], 
+  function(dojox, lang){
+	var du = lang.getObject("lang.utils", true, dojox);
+	
+	var empty = {}, opts = Object.prototype.toString;
+
+	var clone = function(o){
+		if(o){
+			switch(opts.call(o)){
+				case "[object Array]":
+					return o.slice(0);
+				case "[object Object]":
+					return lang.delegate(o);
+			}
+		}
+		return o;
+	}
+	
+	lang.mixin(du, {
+		coerceType: function(target, source){
+			// summary:
+			//		Coerces one object to the type of another.
+			// target: Object
+			//		object, which typeof result is used to coerce "source" object.
+			// source: Object
+			//		object, which will be forced to change type.
+			switch(typeof target){
+				case "number":	return Number(eval("(" + source + ")"));
+				case "string":	return String(source);
+				case "boolean":	return Boolean(eval("(" + source + ")"));
+			}
+			return eval("(" + source + ")");
+		},
+		
+		updateWithObject: function(target, source, conv){
+			// summary:
+			//		Updates an existing object in place with properties from an "source" object.
+			// target: Object
+			//		the "target" object to be updated
+			// source: Object
+			//		the "source" object, whose properties will be used to source the existed object.
+			// conv: Boolean?
+			//		force conversion to the original type
+			if(!source){ return target; }
+			for(var x in target){
+				if(x in source && !(x in empty)){
+					var t = target[x];
+					if(t && typeof t == "object"){
+						du.updateWithObject(t, source[x], conv);
+					}else{
+						target[x] = conv ? du.coerceType(t, source[x]) : clone(source[x]);
+					}
+				}
+			}
+			return target;	// Object
+		},
+	
+		updateWithPattern: function(target, source, pattern, conv){
+			// summary:
+			//		Updates an existing object in place with properties from an "source" object.
+			// target: Object
+			//		the "target" object to be updated
+			// source: Object
+			//		the "source" object, whose properties will be used to source the existed object.
+			// pattern: Object
+			//		object, whose properties will be used to pull values from the "source"
+			// conv: Boolean?
+			//		force conversion to the original type
+			if(!source || !pattern){ return target; }
+			for(var x in pattern){
+				if(x in source && !(x in empty)){
+					target[x] = conv ? du.coerceType(pattern[x], source[x]) : clone(source[x]);
+				}
+			}
+			return target;	// Object
+		},
+		
+		merge: function(object, mixin){
+			// summary:
+			//		Merge two objects structurally, mixin properties will override object's properties.
+			// object: Object
+			//		original object.
+			// mixin: Object
+			//		additional object, which properties will override object's properties.
+			if(mixin){
+				var otype = opts.call(object), mtype = opts.call(mixin), t, i, l, m;
+				switch(mtype){
+					case "[object Array]":
+						if(mtype == otype){
+							t = new Array(Math.max(object.length, mixin.length));
+							for(i = 0, l = t.length; i < l; ++i){
+								t[i] = du.merge(object[i], mixin[i]);
+							}
+							return t;
+						}
+						return mixin.slice(0);
+					case "[object Object]":
+						if(mtype == otype && object){
+							t = lang.delegate(object);
+							for(i in mixin){
+								if(i in object){
+									l = object[i];
+									m = mixin[i];
+									if(m !== l){
+										t[i] = du.merge(l, m);
+									}
+								}else{
+									t[i] = lang.clone(mixin[i]);
+								}
+							}
+							return t;
+						}
+						return lang.clone(mixin);
+				}
+			}
+			return mixin;
+		}
+	});
+	
+	return du;
+});

package/vendor/dojo-1.10.10/dojox/main.js

@@ -0,0 +1,4 @@
+//>>built
+define("dojox/main",["dojo/_base/kernel"],function(_1){
+return _1.dojox;
+});

package/vendor/dojo-1.10.10/dojox/main.js.uncompressed.js

@@ -0,0 +1,14 @@
+define("dojox/main", ["dojo/_base/kernel"], function(dojo) {
+	// module:
+	//		dojox/main
+
+	/*=====
+	return {
+		// summary:
+		//		The dojox package main module; dojox package is somewhat unusual in that the main module currently just provides an empty object.
+		//		Apps should require modules from the dojox packages directly, rather than loading this module.
+	};
+	=====*/
+
+	return dojo.dojox;
+});

package/vendor/dojo-1.10.10/dojox/storage/LocalStorageProvider.js

@@ -0,0 +1,112 @@
+//>>built
+define("dojox/storage/LocalStorageProvider",["dojo","dijit","dojox","dojo/require!dojox/storage/Provider,dojox/storage/manager"],function(_1,_2,_3){
+_1.provide("dojox.storage.LocalStorageProvider");
+_1.require("dojox.storage.Provider");
+_1.require("dojox.storage.manager");
+_1.declare("dojox.storage.LocalStorageProvider",[_3.storage.Provider],{store:null,initialize:function(){
+this.store=localStorage;
+this.initialized=true;
+_3.storage.manager.loaded();
+},isAvailable:function(){
+return typeof localStorage!="undefined";
+},put:function(_4,_5,_6,_7){
+this._assertIsValidKey(_4);
+_7=_7||this.DEFAULT_NAMESPACE;
+this._assertIsValidNamespace(_7);
+var _8=this.getFullKey(_4,_7);
+_5=_1.toJson(_5);
+try{
+this.store.setItem(_8,_5);
+if(_6){
+_6(this.SUCCESS,_4,null,_7);
+}
+}
+catch(e){
+if(_6){
+_6(this.FAILED,_4,e.toString(),_7);
+}
+}
+},get:function(_9,_a){
+this._assertIsValidKey(_9);
+_a=_a||this.DEFAULT_NAMESPACE;
+this._assertIsValidNamespace(_a);
+_9=this.getFullKey(_9,_a);
+return _1.fromJson(this.store.getItem(_9));
+},getKeys:function(_b){
+_b=_b||this.DEFAULT_NAMESPACE;
+this._assertIsValidNamespace(_b);
+_b="__"+_b+"_";
+var _c=[];
+for(var i=0;i<this.store.length;i++){
+var _d=this.store.key(i);
+if(this._beginsWith(_d,_b)){
+_d=_d.substring(_b.length);
+_c.push(_d);
+}
+}
+return _c;
+},clear:function(_e){
+_e=_e||this.DEFAULT_NAMESPACE;
+this._assertIsValidNamespace(_e);
+_e="__"+_e+"_";
+var _f=[];
+for(var i=0;i<this.store.length;i++){
+if(this._beginsWith(this.store.key(i),_e)){
+_f.push(this.store.key(i));
+}
+}
+_1.forEach(_f,_1.hitch(this.store,"removeItem"));
+},remove:function(key,_10){
+_10=_10||this.DEFAULT_NAMESPACE;
+this._assertIsValidNamespace(_10);
+this.store.removeItem(this.getFullKey(key,_10));
+},getNamespaces:function(){
+var _11=[this.DEFAULT_NAMESPACE];
+var _12={};
+_12[this.DEFAULT_NAMESPACE]=true;
+var _13=/^__([^_]*)_/;
+for(var i=0;i<this.store.length;i++){
+var _14=this.store.key(i);
+if(_13.test(_14)==true){
+var _15=_14.match(_13)[1];
+if(typeof _12[_15]=="undefined"){
+_12[_15]=true;
+_11.push(_15);
+}
+}
+}
+return _11;
+},isPermanent:function(){
+return true;
+},getMaximumSize:function(){
+return _3.storage.SIZE_NO_LIMIT;
+},hasSettingsUI:function(){
+return false;
+},isValidKey:function(_16){
+if(_16===null||_16===undefined){
+return false;
+}
+return /^[0-9A-Za-z_-]*$/.test(_16);
+},isValidNamespace:function(_17){
+if(_17===null||_17===undefined){
+return false;
+}
+return /^[0-9A-Za-z-]*$/.test(_17);
+},getFullKey:function(key,_18){
+return "__"+_18+"_"+key;
+},_beginsWith:function(_19,_1a){
+if(_1a.length>_19.length){
+return false;
+}
+return _19.substring(0,_1a.length)===_1a;
+},_assertIsValidNamespace:function(_1b){
+if(this.isValidNamespace(_1b)===false){
+throw new Error("Invalid namespace given: "+_1b);
+}
+},_assertIsValidKey:function(key){
+if(this.isValidKey(key)===false){
+throw new Error("Invalid key given: "+key);
+}
+}});
+_3.storage.manager.register("dojox.storage.LocalStorageProvider",new _3.storage.LocalStorageProvider());
+});

package/vendor/dojo-1.10.10/dojox/storage/LocalStorageProvider.js.uncompressed.js

@@ -0,0 +1,208 @@
+// wrapped by build app
+define("dojox/storage/LocalStorageProvider", ["dojo","dijit","dojox","dojo/require!dojox/storage/Provider,dojox/storage/manager"], function(dojo,dijit,dojox){
+dojo.provide("dojox.storage.LocalStorageProvider");
+
+dojo.require("dojox.storage.Provider");
+dojo.require("dojox.storage.manager");
+
+dojo.declare(
+	"dojox.storage.LocalStorageProvider",
+	[dojox.storage.Provider],
+	{
+		store: null,
+
+		initialize: function(){
+
+			this.store = localStorage;
+
+			this.initialized = true;
+			dojox.storage.manager.loaded();
+		},
+
+		isAvailable: function(){ /*Boolean*/
+			return typeof localStorage != 'undefined';
+		},
+
+		put: function(	/*string*/ key,
+						/*object*/ value,
+						/*function*/ resultsHandler,
+						/*string?*/ namespace){
+
+			// TODO: Use the events as specified in http://dev.w3.org/html5/webstorage/#the-storage-event ?
+			//	Currently, the storage event is not reliable around browsers.
+
+			this._assertIsValidKey(key);
+
+			namespace = namespace||this.DEFAULT_NAMESPACE;
+			this._assertIsValidNamespace(namespace);
+
+			var fullKey = this.getFullKey(key,namespace);
+
+			// prepending a prefix to a string value
+			// will result in that prefix not being
+			// usable as a value, so we better use
+			// toJson() always.
+			value = dojo.toJson(value);
+
+			try { // ua may raise an QUOTA_EXCEEDED_ERR exception
+				this.store.setItem(fullKey,value);
+
+				if(resultsHandler){
+					resultsHandler(this.SUCCESS, key, null, namespace);
+				}
+			} catch(e) {
+				if(resultsHandler){
+					resultsHandler(this.FAILED, key, e.toString(), namespace);
+				}
+			}
+		},
+
+		get: function(/*string*/ key, /*string?*/ namespace){ /*Object*/
+			this._assertIsValidKey(key);
+
+			namespace = namespace||this.DEFAULT_NAMESPACE;
+			this._assertIsValidNamespace(namespace);
+
+			// get our full key name, which is namespace + key
+			key = this.getFullKey(key, namespace);
+
+			return dojo.fromJson(this.store.getItem(key));
+		},
+
+		getKeys: function(/*string?*/ namespace){ /*Array*/
+			namespace = namespace||this.DEFAULT_NAMESPACE;
+			this._assertIsValidNamespace(namespace);
+
+			namespace = '__'+namespace+'_'
+
+			var keys = [];
+			for(var i = 0; i < this.store.length; i++){
+				var currentKey = this.store.key(i);
+				if(this._beginsWith(currentKey,namespace)){
+					currentKey = currentKey.substring(namespace.length);
+					keys.push(currentKey);
+				}
+			}
+
+			return keys;
+		},
+
+		clear: function(/*string?*/ namespace){
+			// Um, well, the 'specs' in Provider.js say that if
+			// no namespace is given, this method should nuke
+			// the *complete* storage. As other components might
+			// be using localStorage too, this might not be a
+			// good idea, so this method won't do it.
+
+			namespace = namespace||this.DEFAULT_NAMESPACE;
+			this._assertIsValidNamespace(namespace);
+
+			namespace = '__'+namespace+'_';
+
+			var keys = [];
+			for(var i = 0; i < this.store.length; i++){
+				if(this._beginsWith(this.store.key(i),namespace)){
+					keys.push(this.store.key(i));
+				}
+			}
+
+			dojo.forEach(keys, dojo.hitch(this.store, "removeItem"));
+		},
+
+		remove: function(/*string*/ key, /*string?*/ namespace){
+			namespace = namespace||this.DEFAULT_NAMESPACE;
+			this._assertIsValidNamespace(namespace);
+
+			this.store.removeItem(this.getFullKey(key, namespace));
+		},
+
+		getNamespaces: function(){ /*string[]*/
+			// There must be a better way than
+			// to execute a regex on *every*
+			// item in the store.
+
+			var results = [ this.DEFAULT_NAMESPACE];
+
+			var found = {};
+			found[this.DEFAULT_NAMESPACE] = true;
+			var tester = /^__([^_]*)_/;
+
+			for(var i = 0; i < this.store.length; i++){
+				var currentKey = this.store.key(i);
+				if(tester.test(currentKey) == true){
+					var currentNS = currentKey.match(tester)[1];
+					if(typeof found[currentNS] == "undefined"){
+						found[currentNS] = true;
+						results.push(currentNS);
+					}
+				}
+			}
+
+			return results;
+		},
+
+		isPermanent: function(){ /*Boolean*/
+			return true;
+		},
+
+		getMaximumSize: function(){ /* mixed */
+			return dojox.storage.SIZE_NO_LIMIT;
+		},
+
+		hasSettingsUI: function(){ /*Boolean*/
+			return false;
+		},
+
+		isValidKey: function(/*string*/ keyName){ /*Boolean*/
+			if(keyName === null || keyName === undefined){
+				return false;
+			}
+
+			return /^[0-9A-Za-z_-]*$/.test(keyName);
+		},
+
+		isValidNamespace: function(/*string*/ keyName){ /*Boolean*/
+			// we *must* prevent namespaces from having
+			// underscores - else lookup of namespaces
+			// via RegEx (e.g. in getNamespaces ) would
+			// return wrong results.
+			//
+			// The only way around this would be to
+			// disallow underscores in keys.
+
+			if(keyName === null || keyName === undefined){
+				return false;
+			}
+
+			return /^[0-9A-Za-z-]*$/.test(keyName);
+		},
+
+		getFullKey: function(key, namespace){
+			// checks for valid namespace and
+			// key are already performed.
+			return "__" + namespace + "_" + key;
+		},
+
+		_beginsWith: function(/* string */ haystack, /* string */ needle) {
+			if(needle.length > haystack.length) {
+				return false;
+			}
+			return haystack.substring(0,needle.length) === needle;
+		},
+
+		_assertIsValidNamespace: function(/* string */ namespace){
+			if(this.isValidNamespace(namespace) === false){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+		},
+
+		_assertIsValidKey: function(/* string */ key){
+			if(this.isValidKey(key) === false){
+				throw new Error("Invalid key given: " + key);
+			}
+		}
+	}
+);
+
+dojox.storage.manager.register("dojox.storage.LocalStorageProvider", new dojox.storage.LocalStorageProvider());
+});

package/vendor/dojo-1.10.10/dojox/storage/Provider.js

@@ -0,0 +1,62 @@
+//>>built
+define("dojox/storage/Provider",["dojo","dijit","dojox"],function(_1,_2,_3){
+_1.provide("dojox.storage.Provider");
+_1.declare("dojox.storage.Provider",null,{constructor:function(){
+},SUCCESS:"success",FAILED:"failed",PENDING:"pending",SIZE_NOT_AVAILABLE:"Size not available",SIZE_NO_LIMIT:"No size limit",DEFAULT_NAMESPACE:"default",onHideSettingsUI:null,initialize:function(){
+console.warn("dojox.storage.initialize not implemented");
+},isAvailable:function(){
+console.warn("dojox.storage.isAvailable not implemented");
+},put:function(_4,_5,_6,_7){
+console.warn("dojox.storage.put not implemented");
+},get:function(_8,_9){
+console.warn("dojox.storage.get not implemented");
+},hasKey:function(_a,_b){
+return !!this.get(_a,_b);
+},getKeys:function(_c){
+console.warn("dojox.storage.getKeys not implemented");
+},clear:function(_d){
+console.warn("dojox.storage.clear not implemented");
+},remove:function(_e,_f){
+console.warn("dojox.storage.remove not implemented");
+},getNamespaces:function(){
+console.warn("dojox.storage.getNamespaces not implemented");
+},isPermanent:function(){
+console.warn("dojox.storage.isPermanent not implemented");
+},getMaximumSize:function(){
+console.warn("dojox.storage.getMaximumSize not implemented");
+},putMultiple:function(_10,_11,_12,_13){
+for(var i=0;i<_10.length;i++){
+_3.storage.put(_10[i],_11[i],_12,_13);
+}
+},getMultiple:function(_14,_15){
+var _16=[];
+for(var i=0;i<_14.length;i++){
+_16.push(_3.storage.get(_14[i],_15));
+}
+return _16;
+},removeMultiple:function(_17,_18){
+for(var i=0;i<_17.length;i++){
+_3.storage.remove(_17[i],_18);
+}
+},isValidKeyArray:function(_19){
+if(_19===null||_19===undefined||!_1.isArray(_19)){
+return false;
+}
+return !_1.some(_19,function(key){
+return !this.isValidKey(key);
+},this);
+},hasSettingsUI:function(){
+return false;
+},showSettingsUI:function(){
+console.warn("dojox.storage.showSettingsUI not implemented");
+},hideSettingsUI:function(){
+console.warn("dojox.storage.hideSettingsUI not implemented");
+},isValidKey:function(_1a){
+if(_1a===null||_1a===undefined){
+return false;
+}
+return /^[0-9A-Za-z_]*$/.test(_1a);
+},getResourceList:function(){
+return [];
+}});
+});