add Dojo 1.1.1

[eow] / static / dojo-release-1.1.1 / dojo / _base / json.js

diff --git a/static/dojo-release-1.1.1/dojo/_base/json.js b/static/dojo-release-1.1.1/dojo/_base/json.js
new file mode 100644 (file)
index 0000000..55d8035
--- /dev/null
+++ b/static/dojo-release-1.1.1/dojo/_base/json.js
@@ -0,0 +1,137 @@
+if(!dojo._hasResource["dojo._base.json"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo._base.json"] = true;
+dojo.provide("dojo._base.json");
+
+dojo.fromJson = function(/*String*/ json){
+       // summary:
+       //              Parses a [JSON](http://json.org) string to return a JavaScript object.
+       // json: 
+       //              a string literal of a JSON item, for instance:
+       //                      `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+
+       return eval("(" + json + ")"); // Object
+}
+
+dojo._escapeString = function(/*String*/str){
+       //summary:
+       //              Adds escape sequences for non-visual characters, double quote and
+       //              backslash and surrounds with double quotes to form a valid string
+       //              literal.
+       return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
+               replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
+               replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
+}
+
+dojo.toJsonIndentStr = "\t";
+dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint, /*String?*/ _indentStr){
+       // summary:
+       //              Returns a [JSON](http://json.org) serialization of an object.
+       //
+       // description:
+       //              Returns a [JSON](http://json.org) serialization of an object.
+       //              Note that this doesn't check for infinite recursion, so don't do that!
+       //
+       // it:
+       //              an object to be serialized. Objects may define their own
+       //              serialization via a special "__json__" or "json" function
+       //              property. If a specialized serializer has been defined, it will
+       //              be used as a fallback.
+       //
+       // prettyPrint:
+       //              if true, we indent objects and arrays to make the output prettier.
+       //              The variable dojo.toJsonIndentStr is used as the indent string 
+       //              -- to use something other than the default (tab), 
+       //              change that variable before calling dojo.toJson().
+       //
+       // _indentStr:
+       //              private variable for recursive calls when pretty printing, do not use.
+
+       if(it === undefined){
+               return "undefined";
+       }
+       var objtype = typeof it;
+       if(objtype == "number" || objtype == "boolean"){
+               return it + "";
+       }
+       if(it === null){
+               return "null";
+       }
+       if(dojo.isString(it)){ 
+               return dojo._escapeString(it); 
+       }
+       if(it.nodeType && it.cloneNode){ // isNode
+               return ""; // FIXME: would something like outerHTML be better here?
+       }
+       // recurse
+       var recurse = arguments.callee;
+       // short-circuit for objects that support "json" serialization
+       // if they return "self" then just pass-through...
+       var newObj;
+       _indentStr = _indentStr || "";
+       var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : "";
+       if(typeof it.__json__ == "function"){
+               newObj = it.__json__();
+               if(it !== newObj){
+                       return recurse(newObj, prettyPrint, nextIndent);
+               }
+       }
+       if(typeof it.json == "function"){
+               newObj = it.json();
+               if(it !== newObj){
+                       return recurse(newObj, prettyPrint, nextIndent);
+               }
+       }
+
+       var sep = prettyPrint ? " " : "";
+       var newLine = prettyPrint ? "\n" : "";
+
+       // array
+       if(dojo.isArray(it)){
+               var res = dojo.map(it, function(obj){
+                       var val = recurse(obj, prettyPrint, nextIndent);
+                       if(typeof val != "string"){
+                               val = "undefined";
+                       }
+                       return newLine + nextIndent + val;
+               });
+               return "[" + res.join("," + sep) + newLine + _indentStr + "]";
+       }
+       /*
+       // look in the registry
+       try {
+               window.o = it;
+               newObj = dojo.json.jsonRegistry.match(it);
+               return recurse(newObj, prettyPrint, nextIndent);
+       }catch(e){
+               // console.debug(e);
+       }
+       // it's a function with no adapter, skip it
+       */
+       if(objtype == "function"){
+               return null; // null
+       }
+       // generic object code path
+       var output = [];
+       for(var key in it){
+               var keyStr;
+               if(typeof key == "number"){
+                       keyStr = '"' + key + '"';
+               }else if(typeof key == "string"){
+                       keyStr = dojo._escapeString(key);
+               }else{
+                       // skip non-string or number keys
+                       continue;
+               }
+               val = recurse(it[key], prettyPrint, nextIndent);
+               if(typeof val != "string"){
+                       // skip non-serializable values
+                       continue;
+               }
+               // FIXME: use += on Moz!!
+               //       MOW NOTE: using += is a pain because you have to account for the dangling comma...
+               output.push(newLine + nextIndent + keyStr + ":" + sep + val);
+       }
+       return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String
+}
+
+}