diff options
author | Andrew Dolgov <[email protected]> | 2012-08-14 19:04:32 +0400 |
---|---|---|
committer | Andrew Dolgov <[email protected]> | 2012-08-14 19:04:32 +0400 |
commit | 0181c0110985cfd2659e81c8cc1ef5a2f73bc697 (patch) | |
tree | e2250a345481fa63cfcf98d76830338ad7eb9818 /lib/dojo/_base | |
parent | 973c4a649fd8f83ed85004f3365f10f9c24d8349 (diff) |
dojo: remove uncompressed files
Diffstat (limited to 'lib/dojo/_base')
21 files changed, 0 insertions, 6930 deletions
diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js deleted file mode 100644 index ed0918093..000000000 --- a/lib/dojo/_base/Color.js.uncompressed.js +++ /dev/null @@ -1,220 +0,0 @@ -define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){ - - var Color = dojo.Color = function(/*Array|String|Object*/ color){ - // summary: - // Takes a named string, hex string, array of rgb or rgba values, - // an object with r, g, b, and a properties, or another `dojo.Color` object - // and creates a new Color instance to work from. - // - // example: - // Work with a Color instance: - // | var c = new dojo.Color(); - // | c.setColor([0,0,0]); // black - // | var hex = c.toHex(); // #000000 - // - // example: - // Work with a node's color: - // | var color = dojo.style("someNode", "backgroundColor"); - // | var n = new dojo.Color(color); - // | // adjust the color some - // | n.r *= .5; - // | console.log(n.toString()); // rgb(128, 255, 255); - if(color){ this.setColor(color); } - }; - - /*===== - lang.mixin(dojo.Color,{ - named:{ - // summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values. - } - }); - =====*/ - - // FIXME: - // there's got to be a more space-efficient way to encode or discover - // these!! Use hex? - Color.named = { - "black": [0,0,0], - "silver": [192,192,192], - "gray": [128,128,128], - "white": [255,255,255], - "maroon": [128,0,0], - "red": [255,0,0], - "purple": [128,0,128], - "fuchsia":[255,0,255], - "green": [0,128,0], - "lime": [0,255,0], - "olive": [128,128,0], - "yellow": [255,255,0], - "navy": [0,0,128], - "blue": [0,0,255], - "teal": [0,128,128], - "aqua": [0,255,255], - "transparent": config.transparentColor || [0,0,0,0] - }; - - lang.extend(Color, { - r: 255, g: 255, b: 255, a: 1, - _set: function(r, g, b, a){ - var t = this; t.r = r; t.g = g; t.b = b; t.a = a; - }, - setColor: function(/*Array|String|Object*/ color){ - // summary: - // Takes a named string, hex string, array of rgb or rgba values, - // an object with r, g, b, and a properties, or another `dojo.Color` object - // and sets this color instance to that value. - // - // example: - // | var c = new dojo.Color(); // no color - // | c.setColor("#ededed"); // greyish - if(lang.isString(color)){ - Color.fromString(color, this); - }else if(lang.isArray(color)){ - Color.fromArray(color, this); - }else{ - this._set(color.r, color.g, color.b, color.a); - if(!(color instanceof Color)){ this.sanitize(); } - } - return this; // dojo.Color - }, - sanitize: function(){ - // summary: - // Ensures the object has correct attributes - // description: - // the default implementation does nothing, include dojo.colors to - // augment it with real checks - return this; // dojo.Color - }, - toRgb: function(){ - // summary: - // Returns 3 component array of rgb values - // example: - // | var c = new dojo.Color("#000000"); - // | console.log(c.toRgb()); // [0,0,0] - var t = this; - return [t.r, t.g, t.b]; // Array - }, - toRgba: function(){ - // summary: - // Returns a 4 component array of rgba values from the color - // represented by this object. - var t = this; - return [t.r, t.g, t.b, t.a]; // Array - }, - toHex: function(){ - // summary: - // Returns a CSS color string in hexadecimal representation - // example: - // | console.log(new dojo.Color([0,0,0]).toHex()); // #000000 - var arr = ArrayUtil.map(["r", "g", "b"], function(x){ - var s = this[x].toString(16); - return s.length < 2 ? "0" + s : s; - }, this); - return "#" + arr.join(""); // String - }, - toCss: function(/*Boolean?*/ includeAlpha){ - // summary: - // Returns a css color string in rgb(a) representation - // example: - // | var c = new dojo.Color("#FFF").toCss(); - // | console.log(c); // rgb('255','255','255') - var t = this, rgb = t.r + ", " + t.g + ", " + t.b; - return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")"; // String - }, - toString: function(){ - // summary: - // Returns a visual representation of the color - return this.toCss(true); // String - } - }); - - Color.blendColors = dojo.blendColors = function( - /*dojo.Color*/ start, - /*dojo.Color*/ end, - /*Number*/ weight, - /*dojo.Color?*/ obj - ){ - // summary: - // Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend, - // can reuse a previously allocated dojo.Color object for the result - var t = obj || new Color(); - ArrayUtil.forEach(["r", "g", "b", "a"], function(x){ - t[x] = start[x] + (end[x] - start[x]) * weight; - if(x != "a"){ t[x] = Math.round(t[x]); } - }); - return t.sanitize(); // dojo.Color - }; - - Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){ - // summary: - // Returns a `dojo.Color` instance from a string of the form - // "rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color` - // object to update with the parsed value and return instead of - // creating a new object. - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/); - return m && Color.fromArray(m[1].split(/\s*,\s*/), obj); // dojo.Color - }; - - Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){ - // summary: - // Converts a hex string with a '#' prefix to a color object. - // Supports 12-bit #rgb shorthand. Optionally accepts a - // `dojo.Color` object to update with the parsed value. - // - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - // - // example: - // | var thing = dojo.colorFromHex("#ededed"); // grey, longhand - // - // example: - // | var thing = dojo.colorFromHex("#000"); // black, shorthand - var t = obj || new Color(), - bits = (color.length == 4) ? 4 : 8, - mask = (1 << bits) - 1; - color = Number("0x" + color.substr(1)); - if(isNaN(color)){ - return null; // dojo.Color - } - ArrayUtil.forEach(["b", "g", "r"], function(x){ - var c = color & mask; - color >>= bits; - t[x] = bits == 4 ? 17 * c : c; - }); - t.a = 1; - return t; // dojo.Color - }; - - Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){ - // summary: - // Builds a `dojo.Color` from a 3 or 4 element array, mapping each - // element in sequence to the rgb(a) values of the color. - // example: - // | var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - var t = obj || new Color(); - t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3])); - if(isNaN(t.a)){ t.a = 1; } - return t.sanitize(); // dojo.Color - }; - - Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){ - // summary: - // Parses `str` for a color value. Accepts hex, rgb, and rgba - // style color values. - // description: - // Acceptable input values for str may include arrays of any form - // accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or - // rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10, - // 10, 50)" - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - var a = Color.named[str]; - return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj); // dojo.Color - }; - - return Color; -}); diff --git a/lib/dojo/_base/Deferred.js.uncompressed.js b/lib/dojo/_base/Deferred.js.uncompressed.js deleted file mode 100644 index 6dc39e96c..000000000 --- a/lib/dojo/_base/Deferred.js.uncompressed.js +++ /dev/null @@ -1,366 +0,0 @@ -define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){ - // module: - // dojo/_base/Deferred - // summary: - // This module defines dojo.Deferred. - - var mutator = function(){}; - var freeze = Object.freeze || function(){}; - // A deferred provides an API for creating and resolving a promise. - dojo.Deferred = function(/*Function?*/ canceller){ - // summary: - // Deferreds provide a generic means for encapsulating an asynchronous - // operation and notifying users of the completion and result of the operation. - // description: - // The dojo.Deferred API is based on the concept of promises that provide a - // generic interface into the eventual completion of an asynchronous action. - // The motivation for promises fundamentally is about creating a - // separation of concerns that allows one to achieve the same type of - // call patterns and logical data flow in asynchronous code as can be - // achieved in synchronous code. Promises allows one - // to be able to call a function purely with arguments needed for - // execution, without conflating the call with concerns of whether it is - // sync or async. One shouldn't need to alter a call's arguments if the - // implementation switches from sync to async (or vice versa). By having - // async functions return promises, the concerns of making the call are - // separated from the concerns of asynchronous interaction (which are - // handled by the promise). - // - // The dojo.Deferred is a type of promise that provides methods for fulfilling the - // promise with a successful result or an error. The most important method for - // working with Dojo's promises is the then() method, which follows the - // CommonJS proposed promise API. An example of using a Dojo promise: - // - // | var resultingPromise = someAsyncOperation.then(function(result){ - // | ... handle result ... - // | }, - // | function(error){ - // | ... handle error ... - // | }); - // - // The .then() call returns a new promise that represents the result of the - // execution of the callback. The callbacks will never affect the original promises value. - // - // The dojo.Deferred instances also provide the following functions for backwards compatibility: - // - // * addCallback(handler) - // * addErrback(handler) - // * callback(result) - // * errback(result) - // - // Callbacks are allowed to return promises themselves, so - // you can build complicated sequences of events with ease. - // - // The creator of the Deferred may specify a canceller. The canceller - // is a function that will be called if Deferred.cancel is called - // before the Deferred fires. You can use this to implement clean - // aborting of an XMLHttpRequest, etc. Note that cancel will fire the - // deferred with a CancelledError (unless your canceller returns - // another kind of error), so the errbacks should be prepared to - // handle that error for cancellable Deferreds. - // example: - // | var deferred = new dojo.Deferred(); - // | setTimeout(function(){ deferred.callback({success: true}); }, 1000); - // | return deferred; - // example: - // Deferred objects are often used when making code asynchronous. It - // may be easiest to write functions in a synchronous manner and then - // split code using a deferred to trigger a response to a long-lived - // operation. For example, instead of register a callback function to - // denote when a rendering operation completes, the function can - // simply return a deferred: - // - // | // callback style: - // | function renderLotsOfData(data, callback){ - // | var success = false - // | try{ - // | for(var x in data){ - // | renderDataitem(data[x]); - // | } - // | success = true; - // | }catch(e){ } - // | if(callback){ - // | callback(success); - // | } - // | } - // - // | // using callback style - // | renderLotsOfData(someDataObj, function(success){ - // | // handles success or failure - // | if(!success){ - // | promptUserToRecover(); - // | } - // | }); - // | // NOTE: no way to add another callback here!! - // example: - // Using a Deferred doesn't simplify the sending code any, but it - // provides a standard interface for callers and senders alike, - // providing both with a simple way to service multiple callbacks for - // an operation and freeing both sides from worrying about details - // such as "did this get called already?". With Deferreds, new - // callbacks can be added at any time. - // - // | // Deferred style: - // | function renderLotsOfData(data){ - // | var d = new dojo.Deferred(); - // | try{ - // | for(var x in data){ - // | renderDataitem(data[x]); - // | } - // | d.callback(true); - // | }catch(e){ - // | d.errback(new Error("rendering failed")); - // | } - // | return d; - // | } - // - // | // using Deferred style - // | renderLotsOfData(someDataObj).then(null, function(){ - // | promptUserToRecover(); - // | }); - // | // NOTE: addErrback and addCallback both return the Deferred - // | // again, so we could chain adding callbacks or save the - // | // deferred for later should we need to be notified again. - // example: - // In this example, renderLotsOfData is synchronous and so both - // versions are pretty artificial. Putting the data display on a - // timeout helps show why Deferreds rock: - // - // | // Deferred style and async func - // | function renderLotsOfData(data){ - // | var d = new dojo.Deferred(); - // | setTimeout(function(){ - // | try{ - // | for(var x in data){ - // | renderDataitem(data[x]); - // | } - // | d.callback(true); - // | }catch(e){ - // | d.errback(new Error("rendering failed")); - // | } - // | }, 100); - // | return d; - // | } - // - // | // using Deferred style - // | renderLotsOfData(someDataObj).then(null, function(){ - // | promptUserToRecover(); - // | }); - // - // Note that the caller doesn't have to change his code at all to - // handle the asynchronous case. - - var result, finished, isError, head, nextListener; - var promise = (this.promise = {}); - - function complete(value){ - if(finished){ - throw new Error("This deferred has already been resolved"); - } - result = value; - finished = true; - notify(); - } - function notify(){ - var mutated; - while(!mutated && nextListener){ - var listener = nextListener; - nextListener = nextListener.next; - if((mutated = (listener.progress == mutator))){ // assignment and check - finished = false; - } - var func = (isError ? listener.error : listener.resolved); - if(func){ - try{ - var newResult = func(result); - if (newResult && typeof newResult.then === "function"){ - newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress")); - continue; - } - var unchanged = mutated && newResult === undefined; - if(mutated && !unchanged){ - isError = newResult instanceof Error; - } - listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult); - }catch(e){ - listener.deferred.reject(e); - } - }else{ - if(isError){ - listener.deferred.reject(result); - }else{ - listener.deferred.resolve(result); - } - } - } - } - // calling resolve will resolve the promise - this.resolve = this.callback = function(value){ - // summary: - // Fulfills the Deferred instance successfully with the provide value - this.fired = 0; - this.results = [value, null]; - complete(value); - }; - - - // calling error will indicate that the promise failed - this.reject = this.errback = function(error){ - // summary: - // Fulfills the Deferred instance as an error with the provided error - isError = true; - this.fired = 1; - complete(error); - this.results = [null, error]; - if(!error || error.log !== false){ - (dojo.config.deferredOnError || function(x){ console.error(x); })(error); - } - }; - // call progress to provide updates on the progress on the completion of the promise - this.progress = function(update){ - // summary: - // Send progress events to all listeners - var listener = nextListener; - while(listener){ - var progress = listener.progress; - progress && progress(update); - listener = listener.next; - } - }; - this.addCallbacks = function(callback, errback){ - // summary: - // Adds callback and error callback for this deferred instance. - // callback: Function? - // The callback attached to this deferred object. - // errback: Function? - // The error callback attached to this deferred object. - // returns: - // Returns this deferred object. - this.then(callback, errback, mutator); - return this; // dojo.Deferred - }; - // provide the implementation of the promise - promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){ - // summary: - // Adds a fulfilledHandler, errorHandler, and progressHandler to be called for - // completion of a promise. The fulfilledHandler is called when the promise - // is fulfilled. The errorHandler is called when a promise fails. The - // progressHandler is called for progress events. All arguments are optional - // and non-function values are ignored. The progressHandler is not only an - // optional argument, but progress events are purely optional. Promise - // providers are not required to ever create progress events. - // - // This function will return a new promise that is fulfilled when the given - // fulfilledHandler or errorHandler callback is finished. This allows promise - // operations to be chained together. The value returned from the callback - // handler is the fulfillment value for the returned promise. If the callback - // throws an error, the returned promise will be moved to failed state. - // - // returns: - // Returns a new promise that represents the result of the - // execution of the callback. The callbacks will never affect the original promises value. - // example: - // An example of using a CommonJS compliant promise: - // | asyncComputeTheAnswerToEverything(). - // | then(addTwo). - // | then(printResult, onError); - // | >44 - // - var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel); - var listener = { - resolved: resolvedCallback, - error: errorCallback, - progress: progressCallback, - deferred: returnDeferred - }; - if(nextListener){ - head = head.next = listener; - } - else{ - nextListener = head = listener; - } - if(finished){ - notify(); - } - return returnDeferred.promise; // Promise - }; - var deferred = this; - promise.cancel = this.cancel = function (){ - // summary: - // Cancels the asynchronous operation - if(!finished){ - var error = canceller && canceller(deferred); - if(!finished){ - if (!(error instanceof Error)){ - error = new Error(error); - } - error.log = false; - deferred.reject(error); - } - } - }; - freeze(promise); - }; - lang.extend(dojo.Deferred, { - addCallback: function (/*Function*/ callback){ - // summary: - // Adds successful callback for this deferred instance. - // returns: - // Returns this deferred object. - return this.addCallbacks(lang.hitch.apply(dojo, arguments)); // dojo.Deferred - }, - - addErrback: function (/*Function*/ errback){ - // summary: - // Adds error callback for this deferred instance. - // returns: - // Returns this deferred object. - return this.addCallbacks(null, lang.hitch.apply(dojo, arguments)); // dojo.Deferred - }, - - addBoth: function (/*Function*/ callback){ - // summary: - // Add handler as both successful callback and error callback for this deferred instance. - // returns: - // Returns this deferred object. - var enclosed = lang.hitch.apply(dojo, arguments); - return this.addCallbacks(enclosed, enclosed); // dojo.Deferred - }, - fired: -1 - }); - - dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){ - // summary: - // This provides normalization between normal synchronous values and - // asynchronous promises, so you can interact with them in a common way - // returns: - // Returns a new promise that represents the result of the execution of callback - // when parameter "promiseOrValue" is promise. - // Returns the execution result of callback when parameter "promiseOrValue" is value. - // example: - // | function printFirstAndLast(items){ - // | dojo.when(findFirst(items), console.log); - // | dojo.when(findLast(items), console.log); - // | } - // | function findFirst(items){ - // | return dojo.when(items, function(items){ - // | return items[0]; - // | }); - // | } - // | function findLast(items){ - // | return dojo.when(items, function(items){ - // | return items[items.length - 1]; - // | }); - // | } - // And now all three of his functions can be used sync or async. - // | printFirstAndLast([1,2,3,4]) will work just as well as - // | printFirstAndLast(dojo.xhrGet(...)); - - if(promiseOrValue && typeof promiseOrValue.then === "function"){ - return promiseOrValue.then(callback, errback, progressHandler); - } - return callback ? callback(promiseOrValue) : promiseOrValue; // Promise - }; - - return dojo.Deferred; -}); diff --git a/lib/dojo/_base/NodeList.js.uncompressed.js b/lib/dojo/_base/NodeList.js.uncompressed.js deleted file mode 100644 index e723fa801..000000000 --- a/lib/dojo/_base/NodeList.js.uncompressed.js +++ /dev/null @@ -1,100 +0,0 @@ -define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){ - // module: - // dojo/_base/NodeList - // summary: - // This module defines dojo.NodeList. - -var NodeList = query.NodeList; - - /*===== - dojo.extend(dojo.NodeList, { - connect: function(methodName, objOrFunc, funcName){ - // summary: - // attach event handlers to every item of the NodeList. Uses dojo.connect() - // so event properties are normalized - // methodName: String - // the name of the method to attach to. For DOM events, this should be - // the lower-case name of the event - // objOrFunc: Object|Function|String - // if 2 arguments are passed (methodName, objOrFunc), objOrFunc should - // reference a function or be the name of the function in the global - // namespace to attach. If 3 arguments are provided - // (methodName, objOrFunc, funcName), objOrFunc must be the scope to - // locate the bound function in - // funcName: String? - // optional. A string naming the function in objOrFunc to bind to the - // event. May also be a function reference. - // example: - // add an onclick handler to every button on the page - // | dojo.query("div:nth-child(odd)").connect("onclick", function(e){ - // | console.log("clicked!"); - // | }); - // example: - // attach foo.bar() to every odd div's onmouseover - // | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar"); - }, - coords: function(){ - // summary: - // Deprecated: Use position() for border-box x/y/w/h - // or marginBox() for margin-box w/h/l/t. - // Returns the box objects of all elements in a node list as - // an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes - // the node passed is each node in this list. - - return dojo.map(this, dojo.coords); // Array - } - }); - - var NodeList = dojo.NodeList; - =====*/ - var nlp = NodeList.prototype; - - // don't bind early to dojo.connect since we no longer explicitly depend on it - nlp.connect = NodeList._adaptAsForEach(function(){ - return dojo.connect.apply(this, arguments); - }); - nlp.coords = NodeList._adaptAsMap(dojo.coords); - - NodeList.events = [ - // summary: - // list of all DOM events used in NodeList - "blur", "focus", "change", "click", "error", "keydown", "keypress", - "keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove", - "mouseout", "mouseover", "mouseup", "submit" - ]; - - // FIXME: pseudo-doc the above automatically generated on-event functions - - // syntactic sugar for DOM events - array.forEach(NodeList.events, function(evt){ - var _oe = "on" + evt; - nlp[_oe] = function(a, b){ - return this.connect(_oe, a, b); - }; - // FIXME: should these events trigger publishes? - /* - return (a ? this.connect(_oe, a, b) : - this.forEach(function(n){ - // FIXME: - // listeners get buried by - // addEventListener and can't be dug back - // out to be triggered externally. - // see: - // http://developer.mozilla.org/en/docs/DOM:element - - console.log(n, evt, _oe); - - // FIXME: need synthetic event support! - var _e = { target: n, faux: true, type: evt }; - // dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt }); - try{ n[evt](_e); }catch(e){ console.log(e); } - try{ n[_oe](_e); }catch(e){ console.log(e); } - }) - ); - */ - } - ); - - dojo.NodeList = NodeList; - return dojo.NodeList; -}); diff --git a/lib/dojo/_base/array.js.uncompressed.js b/lib/dojo/_base/array.js.uncompressed.js deleted file mode 100644 index 06e733b4b..000000000 --- a/lib/dojo/_base/array.js.uncompressed.js +++ /dev/null @@ -1,343 +0,0 @@ -define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ - // module: - // dojo/_base/array - // summary: - // This module defines the Javascript v1.6 array extensions. - - /*===== - dojo.indexOf = function(arr, value, fromIndex, findLast){ - // summary: - // locates the first index of the provided value in the - // passed array. If the value is not found, -1 is returned. - // description: - // This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when - // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript - // 1.6's indexOf skips the holes in the sparse array. - // For details on this method, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf - // arr: Array - // value: Object - // fromIndex: Integer? - // findLast: Boolean? - // returns: Number - }; - dojo.lastIndexOf = function(arr, value, fromIndex){ - // summary: - // locates the last index of the provided value in the passed - // array. If the value is not found, -1 is returned. - // description: - // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when - // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript - // 1.6's lastIndexOf skips the holes in the sparse array. - // For details on this method, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf - // arr: Array, - // value: Object, - // fromIndex: Integer? - // returns: Number - }; - dojo.forEach = function(arr, callback, thisObject){ - // summary: - // for every item in arr, callback is invoked. Return values are ignored. - // If you want to break out of the loop, consider using dojo.every() or dojo.some(). - // forEach does not allow breaking out of the loop over the items in arr. - // arr: - // the array to iterate over. If a string, operates on individual characters. - // callback: - // a function is invoked with three arguments: item, index, and array - // thisObject: - // may be used to scope the call to callback - // description: - // This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when - // run over sparse arrays, this implementation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach - // example: - // | // log out all members of the array: - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | function(item){ - // | console.log(item); - // | } - // | ); - // example: - // | // log out the members and their indexes - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | function(item, idx, arr){ - // | console.log(item, "at index:", idx); - // | } - // | ); - // example: - // | // use a scoped object member as the callback - // | - // | var obj = { - // | prefix: "logged via obj.callback:", - // | callback: function(item){ - // | console.log(this.prefix, item); - // | } - // | }; - // | - // | // specifying the scope function executes the callback in that scope - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | obj.callback, - // | obj - // | ); - // | - // | // alternately, we can accomplish the same thing with dojo.hitch() - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | dojo.hitch(obj, "callback") - // | ); - // arr: Array|String - // callback: Function|String - // thisObject: Object? - }; - dojo.every = function(arr, callback, thisObject){ - // summary: - // Determines whether or not every item in arr satisfies the - // condition implemented by callback. - // arr: Array|String - // the array to iterate on. If a string, operates on individual characters. - // callback: Function|String - // a function is invoked with three arguments: item, index, - // and array and returns true if the condition is met. - // thisObject: Object? - // may be used to scope the call to callback - // returns: Boolean - // description: - // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when - // run over sparse arrays, this implementation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every - // example: - // | // returns false - // | dojo.every([1, 2, 3, 4], function(item){ return item>1; }); - // example: - // | // returns true - // | dojo.every([1, 2, 3, 4], function(item){ return item>0; }); - }; - dojo.some = function(arr, callback, thisObject){ - // summary: - // Determines whether or not any item in arr satisfies the - // condition implemented by callback. - // arr: Array|String - // the array to iterate over. If a string, operates on individual characters. - // callback: Function|String - // a function is invoked with three arguments: item, index, - // and array and returns true if the condition is met. - // thisObject: Object? - // may be used to scope the call to callback - // returns: Boolean - // description: - // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when - // run over sparse arrays, this implementation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some - // example: - // | // is true - // | dojo.some([1, 2, 3, 4], function(item){ return item>1; }); - // example: - // | // is false - // | dojo.some([1, 2, 3, 4], function(item){ return item<1; }); - }; - dojo.map = function(arr, callback, thisObject){ - // summary: - // applies callback to each element of arr and returns - // an Array with the results - // arr: Array|String - // the array to iterate on. If a string, operates on - // individual characters. - // callback: Function|String - // a function is invoked with three arguments, (item, index, - // array), and returns a value - // thisObject: Object? - // may be used to scope the call to callback - // returns: Array - // description: - // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when - // run over sparse arrays, this implementation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map - // example: - // | // returns [2, 3, 4, 5] - // | dojo.map([1, 2, 3, 4], function(item){ return item+1 }); - }; - dojo.filter = function(arr, callback, thisObject){ - // summary: - // Returns a new Array with those items from arr that match the - // condition implemented by callback. - // arr: Array - // the array to iterate over. - // callback: Function|String - // a function that is invoked with three arguments (item, - // index, array). The return of this function is expected to - // be a boolean which determines whether the passed-in item - // will be included in the returned array. - // thisObject: Object? - // may be used to scope the call to callback - // returns: Array - // description: - // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when - // run over sparse arrays, this implementation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter - // example: - // | // returns [2, 3, 4] - // | dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); - }; - =====*/ - - // our old simple function builder stuff - var cache = {}, u, array; // the export object - - function clearCache(){ - cache = {}; - } - - function buildFn(fn){ - return cache[fn] = new Function("item", "index", "array", fn); // Function - } - // magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn); - - // every & some - - function everyOrSome(some){ - var every = !some; - return function(a, fn, o){ - var i = 0, l = a && a.length || 0, result; - if(l && typeof a == "string") a = a.split(""); - if(typeof fn == "string") fn = cache[fn] || buildFn(fn); - if(o){ - for(; i < l; ++i){ - result = !fn.call(o, a[i], i, a); - if(some ^ result){ - return !result; - } - } - }else{ - for(; i < l; ++i){ - result = !fn(a[i], i, a); - if(some ^ result){ - return !result; - } - } - } - return every; // Boolean - } - } - // var every = everyOrSome(false), some = everyOrSome(true); - - // indexOf, lastIndexOf - - function index(up){ - var delta = 1, lOver = 0, uOver = 0; - if(!up){ - delta = lOver = uOver = -1; - } - return function(a, x, from, last){ - if(last && delta > 0){ - // TODO: why do we use a non-standard signature? why do we need "last"? - return array.lastIndexOf(a, x, from); - } - var l = a && a.length || 0, end = up ? l + uOver : lOver, i; - if(from === u){ - i = up ? lOver : l + uOver; - }else{ - if(from < 0){ - i = l + from; - if(i < 0){ - i = lOver; - } - }else{ - i = from >= l ? l + uOver : from; - } - } - if(l && typeof a == "string") a = a.split(""); - for(; i != end; i += delta){ - if(a[i] == x){ - return i; // Number - } - } - return -1; // Number - } - } - // var indexOf = index(true), lastIndexOf = index(false); - - function forEach(a, fn, o){ - var i = 0, l = a && a.length || 0; - if(l && typeof a == "string") a = a.split(""); - if(typeof fn == "string") fn = cache[fn] || buildFn(fn); - if(o){ - for(; i < l; ++i){ - fn.call(o, a[i], i, a); - } - }else{ - for(; i < l; ++i){ - fn(a[i], i, a); - } - } - } - - function map(a, fn, o, Ctr){ - // TODO: why do we have a non-standard signature here? do we need "Ctr"? - var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l); - if(l && typeof a == "string") a = a.split(""); - if(typeof fn == "string") fn = cache[fn] || buildFn(fn); - if(o){ - for(; i < l; ++i){ - out[i] = fn.call(o, a[i], i, a); - } - }else{ - for(; i < l; ++i){ - out[i] = fn(a[i], i, a); - } - } - return out; // Array - } - - function filter(a, fn, o){ - // TODO: do we need "Ctr" here like in map()? - var i = 0, l = a && a.length || 0, out = [], value; - if(l && typeof a == "string") a = a.split(""); - if(typeof fn == "string") fn = cache[fn] || buildFn(fn); - if(o){ - for(; i < l; ++i){ - value = a[i]; - if(fn.call(o, value, i, a)){ - out.push(value); - } - } - }else{ - for(; i < l; ++i){ - value = a[i]; - if(fn(value, i, a)){ - out.push(value); - } - } - } - return out; // Array - } - - array = { - every: everyOrSome(false), - some: everyOrSome(true), - indexOf: index(true), - lastIndexOf: index(false), - forEach: forEach, - map: map, - filter: filter, - clearCache: clearCache - }; - - 1 && lang.mixin(dojo, array); - - /*===== return dojo.array; =====*/ - return array; -}); diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js deleted file mode 100644 index 8f186e2a1..000000000 --- a/lib/dojo/_base/browser.js.uncompressed.js +++ /dev/null @@ -1,21 +0,0 @@ -if(require.has){ - require.has.add("config-selectorEngine", "acme"); -} -define("dojo/_base/browser", [ - "../ready", - "./kernel", - "./connect", // until we decide if connect is going back into non-browser environments - "./unload", - "./window", - "./event", - "./html", - "./NodeList", - "../query", - "./xhr", - "./fx"], function(dojo) { - // module: - // dojo/_base/browser - // summary: - // This module causes the browser-only base modules to be loaded. - return dojo; -}); diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js deleted file mode 100644 index 290efd10a..000000000 --- a/lib/dojo/_base/config.js.uncompressed.js +++ /dev/null @@ -1,174 +0,0 @@ -define("dojo/_base/config", ["../has", "require"], function(has, require){ - // module: - // dojo/_base/config - // summary: - // This module defines the user configuration during bootstrap. - // description: - // By defining user configuration as a module value, an entire configuration can be specified in a build, - // thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig. - // Also, when multiple instances of dojo exist in a single application, each will necessarily be located - // at an unique absolute module identifier as given by the package configuration. Implementing configuration - // as a module allows for specifying unique, per-instance configurations. - // example: - // Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and - // dojo.js are already loaded). - // | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo" - // | require({ - // | packages:[{ - // | name:"myDojo", - // | location:".", //assume baseUrl points to dojo.js - // | }] - // | }); - // | - // | // specify a configuration for the myDojo instance - // | define("myDojo/config", { - // | // normal configuration variables go here, e.g., - // | locale:"fr-ca" - // | }); - // | - // | // load and use the new instance of dojo - // | require(["myDojo"], function(dojo) { - // | // dojo is the new instance of dojo - // | // use as required - // | }); - - var result = {}; - if(1){ - // must be the dojo loader; take a shallow copy of require.rawConfig - var src = require.rawConfig, p; - for(p in src){ - result[p] = src[p]; - } - }else{ - var adviseHas = function(featureSet, prefix, booting){ - for(p in featureSet){ - p!="has" && has.add(prefix + p, featureSet[p], 0, booting); - } - }; - result = 1 ? - // must be a built version of the dojo loader; all config stuffed in require.rawConfig - require.rawConfig : - // a foreign loader - this.dojoConfig || this.djConfig || {}; - adviseHas(result, "config", 1); - adviseHas(result.has, "", 1); - } - return result; - -/*===== -// note: -// 'dojoConfig' does not exist under 'dojo.*' so that it can be set before the -// 'dojo' variable exists. -// note: -// Setting any of these variables *after* the library has loaded does -// nothing at all. - -// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js - -dojoConfig = { - // summary: - // Application code can set the global 'dojoConfig' prior to loading - // the library to control certain global settings for how dojo works. - // - // isDebug: Boolean - // Defaults to `false`. If set to `true`, ensures that Dojo provides - // extended debugging feedback via Firebug. If Firebug is not available - // on your platform, setting `isDebug` to `true` will force Dojo to - // pull in (and display) the version of Firebug Lite which is - // integrated into the Dojo distribution, thereby always providing a - // debugging/logging console when `isDebug` is enabled. Note that - // Firebug's `console.*` methods are ALWAYS defined by Dojo. If - // `isDebug` is false and you are on a platform without Firebug, these - // methods will be defined as no-ops. - isDebug: false, - // locale: String - // The locale to assume for loading localized resources in this page, - // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt). - // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`. - // See the documentation for `dojo.i18n` and `dojo.requireLocalization` - // for details on loading localized resources. If no locale is specified, - // Dojo assumes the locale of the user agent, according to `navigator.userLanguage` - // or `navigator.language` properties. - locale: undefined, - // extraLocale: Array - // No default value. Specifies additional locales whose - // resources should also be loaded alongside the default locale when - // calls to `dojo.requireLocalization()` are processed. - extraLocale: undefined, - // baseUrl: String - // The directory in which `dojo.js` is located. Under normal - // conditions, Dojo auto-detects the correct location from which it - // was loaded. You may need to manually configure `baseUrl` in cases - // where you have renamed `dojo.js` or in which `<base>` tags confuse - // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned - // either the value of `djConfig.baseUrl` if one is provided or the - // auto-detected root if not. Other modules are located relative to - // this path. The path should end in a slash. - baseUrl: undefined, - // modulePaths: Object - // A map of module names to paths relative to `dojo.baseUrl`. The - // key/value pairs correspond directly to the arguments which - // `dojo.registerModulePath` accepts. Specifiying - // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent - // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple - // modules may be configured via `djConfig.modulePaths`. - modulePaths: {}, - // afterOnLoad: Boolean - // Indicates Dojo was added to the page after the page load. In this case - // Dojo will not wait for the page DOMContentLoad/load events and fire - // its dojo.addOnLoad callbacks after making sure all outstanding - // dojo.required modules have loaded. Only works with a built dojo.js, - // it does not work the dojo.js directly from source control. - afterOnLoad: false, - // addOnLoad: Function or Array - // Adds a callback via dojo.addOnLoad. Useful when Dojo is added after - // the page loads and djConfig.afterOnLoad is true. Supports the same - // arguments as dojo.addOnLoad. When using a function reference, use - // `djConfig.addOnLoad = function(){};`. For object with function name use - // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with - // function reference use - // `djConfig.addOnLoad = [myObject, function(){}];` - addOnLoad: null, - // require: Array - // An array of module names to be loaded immediately after dojo.js has been included - // in a page. - require: [], - // defaultDuration: Array - // Default duration, in milliseconds, for wipe and fade animations within dijits. - // Assigned to dijit.defaultDuration. - defaultDuration: 200, - // dojoBlankHtmlUrl: String - // Used by some modules to configure an empty iframe. Used by dojo.io.iframe and - // dojo.back, and dijit popup support in IE where an iframe is needed to make sure native - // controls do not bleed through the popups. Normally this configuration variable - // does not need to be set, except when using cross-domain/CDN Dojo builds. - // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl` - // to the path on your domain your copy of blank.html. - dojoBlankHtmlUrl: undefined, - // ioPublish: Boolean? - // Set this to true to enable publishing of topics for the different phases of - // IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list - // of topics that are published. - ioPublish: false, - // useCustomLogger: Anything? - // If set to a value that evaluates to true such as a string or array and - // isDebug is true and Firebug is not available or running, then it bypasses - // the creation of Firebug Lite allowing you to define your own console object. - useCustomLogger: undefined, - // transparentColor: Array - // Array containing the r, g, b components used as transparent color in dojo.Color; - // if undefined, [255,255,255] (white) will be used. - transparentColor: undefined, - // skipIeDomLoaded: Boolean - // For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation - // Aborted error if the rest of the page triggers script defers before the DOM is ready. - // If this is config value is set to true, then dojo.addOnLoad callbacks will not be - // triggered until the page load event, which is after images and iframes load. If you - // want to trigger the callbacks sooner, you can put a script block in the bottom of - // your HTML that calls dojo._loadInit();. If you are using multiversion support, change - // "dojo." to the appropriate scope name for dojo. - skipIeDomLoaded: false -} -=====*/ -}); - diff --git a/lib/dojo/_base/connect.js.uncompressed.js b/lib/dojo/_base/connect.js.uncompressed.js deleted file mode 100644 index 69de83e70..000000000 --- a/lib/dojo/_base/connect.js.uncompressed.js +++ /dev/null @@ -1,400 +0,0 @@ -define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){ -// module: -// dojo/_base/connect -// summary: -// This module defines the dojo.connect API. -// This modules also provides keyboard event handling helpers. -// This module exports an extension event for emulating Firefox's keypress handling. -// However, this extension event exists primarily for backwards compatibility and -// is not recommended. WebKit and IE uses an alternate keypress handling (only -// firing for printable characters, to distinguish from keydown events), and most -// consider the WebKit/IE behavior more desirable. -has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit - var testKeyEvent = {charCode: 0}; - try{ - testKeyEvent = document.createEvent("KeyboardEvent"); - (testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3); - }catch(e){} - return testKeyEvent.charCode == 0 && !has("opera"); -}); - -function connect_(obj, event, context, method, dontFix){ - method = lang.hitch(context, method); - if(!obj || !(obj.addEventListener || obj.attachEvent)){ - // it is a not a DOM node and we are using the dojo.connect style of treating a - // method like an event, must go right to aspect - return aspect.after(obj || kernel.global, event, method, true); - } - if(typeof event == "string" && event.substring(0, 2) == "on"){ - event = event.substring(2); - } - if(!obj){ - obj = kernel.global; - } - if(!dontFix){ - switch(event){ - // dojo.connect has special handling for these event types - case "keypress": - event = keypress; - break; - case "mouseenter": - event = mouse.enter; - break; - case "mouseleave": - event = mouse.leave; - break; - } - } - return on(obj, event, method, dontFix); -} - -var _punctMap = { - 106:42, - 111:47, - 186:59, - 187:43, - 188:44, - 189:45, - 190:46, - 191:47, - 192:96, - 219:91, - 220:92, - 221:93, - 222:39, - 229:113 -}; -var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey"; - - -var _synthesizeEvent = function(evt, props){ - var faux = lang.mixin({}, evt, props); - setKeyChar(faux); - // FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault); - // but it throws an error when preventDefault is invoked on Safari - // does Event.preventDefault not support "apply" on Safari? - faux.preventDefault = function(){ evt.preventDefault(); }; - faux.stopPropagation = function(){ evt.stopPropagation(); }; - return faux; -}; -function setKeyChar(evt){ - evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : ''; - evt.charOrCode = evt.keyChar || evt.keyCode; -} -var keypress; -if(has("events-keypress-typed")){ - // this emulates Firefox's keypress behavior where every keydown can correspond to a keypress - var _trySetKeyCode = function(e, code){ - try{ - // squelch errors when keyCode is read-only - // (e.g. if keyCode is ctrl or shift) - return (e.keyCode = code); - }catch(e){ - return 0; - } - }; - keypress = function(object, listener){ - var keydownSignal = on(object, "keydown", function(evt){ - // munge key/charCode - var k=evt.keyCode; - // These are Windows Virtual Key Codes - // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp - var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229; - // synthesize keypress for most unprintables and CTRL-keys - if(unprintable||evt.ctrlKey){ - var c = unprintable ? 0 : k; - if(evt.ctrlKey){ - if(k==3 || k==13){ - return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively - }else if(c>95 && c<106){ - c -= 48; // map CTRL-[numpad 0-9] to ASCII - }else if((!evt.shiftKey)&&(c>=65&&c<=90)){ - c += 32; // map CTRL-[A-Z] to lowercase - }else{ - c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII - } - } - // simulate a keypress event - var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c}); - listener.call(evt.currentTarget, faux); - if(has("ie")){ - _trySetKeyCode(evt, faux.keyCode); - } - } - }); - var keypressSignal = on(object, "keypress", function(evt){ - var c = evt.charCode; - c = c>=32 ? c : 0; - evt = _synthesizeEvent(evt, {charCode: c, faux: true}); - return listener.call(this, evt); - }); - return { - remove: function(){ - keydownSignal.remove(); - keypressSignal.remove(); - } - }; - }; -}else{ - if(has("opera")){ - keypress = function(object, listener){ - return on(object, "keypress", function(evt){ - var c = evt.which; - if(c==3){ - c=99; // Mozilla maps CTRL-BREAK to CTRL-c - } - // can't trap some keys at all, like INSERT and DELETE - // there is no differentiating info between DELETE and ".", or INSERT and "-" - c = c<32 && !evt.shiftKey ? 0 : c; - if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){ - // lowercase CTRL-[A-Z] keys - c += 32; - } - return listener.call(this, _synthesizeEvent(evt, { charCode: c })); - }); - }; - }else{ - keypress = function(object, listener){ - return on(object, "keypress", function(evt){ - setKeyChar(evt); - return listener.call(this, evt); - }); - }; - } -} - -var connect = { - _keypress:keypress, - - connect:function(obj, event, context, method, dontFix){ - // normalize arguments - var a=arguments, args=[], i=0; - // if a[0] is a String, obj was omitted - args.push(typeof a[0] == "string" ? null : a[i++], a[i++]); - // if the arg-after-next is a String or Function, context was NOT omitted - var a1 = a[i+1]; - args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]); - // absorb any additional arguments - for(var l=a.length; i<l; i++){ args.push(a[i]); } - return connect_.apply(this, args); - }, - - disconnect:function(handle){ - if(handle){ - handle.remove(); - } - }, - - subscribe:function(topic, context, method){ - return hub.subscribe(topic, lang.hitch(context, method)); - }, - - publish:function(topic, args){ - return hub.publish.apply(hub, [topic].concat(args)); - }, - - connectPublisher:function(topic, obj, event){ - var pf = function(){ connect.publish(topic, arguments); }; - return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle - }, - - isCopyKey: function(e){ - return e[evtCopyKey]; // Boolean - } -}; -connect.unsubscribe = connect.disconnect; - -1 && lang.mixin(kernel, connect); -return connect; - -/*===== -dojo.connect = function(obj, event, context, method, dontFix){ - // summary: - // `dojo.connect` is the core event handling and delegation method in - // Dojo. It allows one function to "listen in" on the execution of - // any other, triggering the second whenever the first is called. Many - // listeners may be attached to a function, and source functions may - // be either regular function calls or DOM events. - // - // description: - // Connects listeners to actions, so that after event fires, a - // listener is called with the same arguments passed to the original - // function. - // - // Since `dojo.connect` allows the source of events to be either a - // "regular" JavaScript function or a DOM event, it provides a uniform - // interface for listening to all the types of events that an - // application is likely to deal with though a single, unified - // interface. DOM programmers may want to think of it as - // "addEventListener for everything and anything". - // - // When setting up a connection, the `event` parameter must be a - // string that is the name of the method/event to be listened for. If - // `obj` is null, `kernel.global` is assumed, meaning that connections - // to global methods are supported but also that you may inadvertently - // connect to a global by passing an incorrect object name or invalid - // reference. - // - // `dojo.connect` generally is forgiving. If you pass the name of a - // function or method that does not yet exist on `obj`, connect will - // not fail, but will instead set up a stub method. Similarly, null - // arguments may simply be omitted such that fewer than 4 arguments - // may be required to set up a connection See the examples for details. - // - // The return value is a handle that is needed to - // remove this connection with `dojo.disconnect`. - // - // obj: Object|null: - // The source object for the event function. - // Defaults to `kernel.global` if null. - // If obj is a DOM node, the connection is delegated - // to the DOM event manager (unless dontFix is true). - // - // event: String: - // String name of the event function in obj. - // I.e. identifies a property `obj[event]`. - // - // context: Object|null - // The object that method will receive as "this". - // - // If context is null and method is a function, then method - // inherits the context of event. - // - // If method is a string then context must be the source - // object object for method (context[method]). If context is null, - // kernel.global is used. - // - // method: String|Function: - // A function reference, or name of a function in context. - // The function identified by method fires after event does. - // method receives the same arguments as the event. - // See context argument comments for information on method's scope. - // - // dontFix: Boolean? - // If obj is a DOM node, set dontFix to true to prevent delegation - // of this connection to the DOM event manager. - // - // example: - // When obj.onchange(), do ui.update(): - // | dojo.connect(obj, "onchange", ui, "update"); - // | dojo.connect(obj, "onchange", ui, ui.update); // same - // - // example: - // Using return value for disconnect: - // | var link = dojo.connect(obj, "onchange", ui, "update"); - // | ... - // | dojo.disconnect(link); - // - // example: - // When onglobalevent executes, watcher.handler is invoked: - // | dojo.connect(null, "onglobalevent", watcher, "handler"); - // - // example: - // When ob.onCustomEvent executes, customEventHandler is invoked: - // | dojo.connect(ob, "onCustomEvent", null, "customEventHandler"); - // | dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same - // - // example: - // When ob.onCustomEvent executes, customEventHandler is invoked - // with the same scope (this): - // | dojo.connect(ob, "onCustomEvent", null, customEventHandler); - // | dojo.connect(ob, "onCustomEvent", customEventHandler); // same - // - // example: - // When globalEvent executes, globalHandler is invoked - // with the same scope (this): - // | dojo.connect(null, "globalEvent", null, globalHandler); - // | dojo.connect("globalEvent", globalHandler); // same -} -=====*/ - -/*===== -dojo.disconnect = function(handle){ - // summary: - // Remove a link created by dojo.connect. - // description: - // Removes the connection between event and the method referenced by handle. - // handle: Handle: - // the return value of the dojo.connect call that created the connection. -} -=====*/ - -/*===== -dojo.subscribe = function(topic, context, method){ - // summary: - // Attach a listener to a named topic. The listener function is invoked whenever the - // named topic is published (see: dojo.publish). - // Returns a handle which is needed to unsubscribe this listener. - // topic: String: - // The topic to which to subscribe. - // context: Object|null: - // Scope in which method will be invoked, or null for default scope. - // method: String|Function: - // The name of a function in context, or a function reference. This is the function that - // is invoked when topic is published. - // example: - // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); }); - // | dojo.publish("alerts", [ "read this", "hello world" ]); -} -=====*/ - -/*===== -dojo.unsubscribe = function(handle){ - // summary: - // Remove a topic listener. - // handle: Handle - // The handle returned from a call to subscribe. - // example: - // | var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); }; - // | ... - // | dojo.unsubscribe(alerter); -} -=====*/ - -/*===== -dojo.publish = function(topic, args){ - // summary: - // Invoke all listener method subscribed to topic. - // topic: String: - // The name of the topic to publish. - // args: Array? - // An array of arguments. The arguments will be applied - // to each topic subscriber (as first class parameters, via apply). - // example: - // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); }; - // | dojo.publish("alerts", [ "read this", "hello world" ]); -} -=====*/ - -/*===== -dojo.connectPublisher = function(topic, obj, event){ - // summary: - // Ensure that every time obj.event() is called, a message is published - // on the topic. Returns a handle which can be passed to - // dojo.disconnect() to disable subsequent automatic publication on - // the topic. - // topic: String: - // The name of the topic to publish. - // obj: Object|null: - // The source object for the event function. Defaults to kernel.global - // if null. - // event: String: - // The name of the event function in obj. - // I.e. identifies a property obj[event]. - // example: - // | dojo.connectPublisher("/ajax/start", dojo, "xhrGet"); -} -=====*/ - -/*===== -dojo.isCopyKey = function(e){ - // summary: - // Checks an event for the copy key (meta on Mac, and ctrl anywhere else) - // e: Event - // Event object to examine -} -=====*/ - -}); - - diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js deleted file mode 100644 index 838bf1c81..000000000 --- a/lib/dojo/_base/declare.js.uncompressed.js +++ /dev/null @@ -1,1050 +0,0 @@ -define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ - // module: - // dojo/_base/declare - // summary: - // This module defines dojo.declare. - - var mix = lang.mixin, op = Object.prototype, opts = op.toString, - xtor = new Function, counter = 0, cname = "constructor"; - - function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); } - - // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/) - function c3mro(bases, className){ - var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1, - l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs; - - // build a list of bases naming them if needed - for(; i < l; ++i){ - base = bases[i]; - if(!base){ - err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className); - }else if(opts.call(base) != "[object Function]"){ - err("mixin #" + i + " is not a callable constructor.", className); - } - lin = base._meta ? base._meta.bases : [base]; - top = 0; - // add bases to the name map - for(j = lin.length - 1; j >= 0; --j){ - proto = lin[j].prototype; - if(!proto.hasOwnProperty("declaredClass")){ - proto.declaredClass = "uniqName_" + (counter++); - } - name = proto.declaredClass; - if(!nameMap.hasOwnProperty(name)){ - nameMap[name] = {count: 0, refs: [], cls: lin[j]}; - ++clsCount; - } - rec = nameMap[name]; - if(top && top !== rec){ - rec.refs.push(top); - ++top.count; - } - top = rec; - } - ++top.count; - roots[0].refs.push(top); - } - - // remove classes without external references recursively - while(roots.length){ - top = roots.pop(); - result.push(top.cls); - --clsCount; - // optimization: follow a single-linked chain - while(refs = top.refs, refs.length == 1){ - top = refs[0]; - if(!top || --top.count){ - // branch or end of chain => do not end to roots - top = 0; - break; - } - result.push(top.cls); - --clsCount; - } - if(top){ - // branch - for(i = 0, l = refs.length; i < l; ++i){ - top = refs[i]; - if(!--top.count){ - roots.push(top); - } - } - } - } - if(clsCount){ - err("can't build consistent linearization", className); - } - - // calculate the superclass offset - base = bases[0]; - result[0] = base ? - base._meta && base === result[result.length - base._meta.bases.length] ? - base._meta.bases.length : 1 : 0; - - return result; - } - - function inherited(args, a, f){ - var name, chains, bases, caller, meta, base, proto, opf, pos, - cache = this._inherited = this._inherited || {}; - - // crack arguments - if(typeof args == "string"){ - name = args; - args = a; - a = f; - } - f = 0; - - caller = args.callee; - name = name || caller.nom; - if(!name){ - err("can't deduce a name to call inherited()", this.declaredClass); - } - - meta = this.constructor._meta; - bases = meta.bases; - - pos = cache.p; - if(name != cname){ - // method - if(cache.c !== caller){ - // cache bust - pos = 0; - base = bases[0]; - meta = base._meta; - if(meta.hidden[name] !== caller){ - // error detection - chains = meta.chains; - if(chains && typeof chains[name] == "string"){ - err("calling chained method with inherited: " + name, this.declaredClass); - } - // find caller - do{ - meta = base._meta; - proto = base.prototype; - if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){ - break; - } - }while(base = bases[++pos]); // intentional assignment - pos = base ? pos : -1; - } - } - // find next - base = bases[++pos]; - if(base){ - proto = base.prototype; - if(base._meta && proto.hasOwnProperty(name)){ - f = proto[name]; - }else{ - opf = op[name]; - do{ - proto = base.prototype; - f = proto[name]; - if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){ - break; - } - }while(base = bases[++pos]); // intentional assignment - } - } - f = base && f || op[name]; - }else{ - // constructor - if(cache.c !== caller){ - // cache bust - pos = 0; - meta = bases[0]._meta; - if(meta && meta.ctor !== caller){ - // error detection - chains = meta.chains; - if(!chains || chains.constructor !== "manual"){ - err("calling chained constructor with inherited", this.declaredClass); - } - // find caller - while(base = bases[++pos]){ // intentional assignment - meta = base._meta; - if(meta && meta.ctor === caller){ - break; - } - } - pos = base ? pos : -1; - } - } - // find next - while(base = bases[++pos]){ // intentional assignment - meta = base._meta; - f = meta ? meta.ctor : base; - if(f){ - break; - } - } - f = base && f; - } - - // cache the found super method - cache.c = f; - cache.p = pos; - - // now we have the result - if(f){ - return a === true ? f : f.apply(this, a || args); - } - // intentionally no return if a super method was not found - } - - function getInherited(name, args){ - if(typeof name == "string"){ - return this.__inherited(name, args, true); - } - return this.__inherited(name, true); - } - - function inherited__debug(args, a1, a2){ - var f = this.getInherited(args, a1); - if(f){ return f.apply(this, a2 || a1 || args); } - // intentionally no return if a super method was not found - } - - var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited; - - // emulation of "instanceof" - function isInstanceOf(cls){ - var bases = this.constructor._meta.bases; - for(var i = 0, l = bases.length; i < l; ++i){ - if(bases[i] === cls){ - return true; - } - } - return this instanceof cls; - } - - function mixOwn(target, source){ - // add props adding metadata for incoming functions skipping a constructor - for(var name in source){ - if(name != cname && source.hasOwnProperty(name)){ - target[name] = source[name]; - } - } - if(has("bug-for-in-skips-shadowed")){ - for(var extraNames= lang._extraNames, i= extraNames.length; i;){ - name = extraNames[--i]; - if(name != cname && source.hasOwnProperty(name)){ - target[name] = source[name]; - } - } - } - } - - // implementation of safe mixin function - function safeMixin(target, source){ - var name, t; - // add props adding metadata for incoming functions skipping a constructor - for(name in source){ - t = source[name]; - if((t !== op[name] || !(name in op)) && name != cname){ - if(opts.call(t) == "[object Function]"){ - // non-trivial function method => attach its name - t.nom = name; - } - target[name] = t; - } - } - if(has("bug-for-in-skips-shadowed")){ - for(var extraNames= lang._extraNames, i= extraNames.length; i;){ - name = extraNames[--i]; - t = source[name]; - if((t !== op[name] || !(name in op)) && name != cname){ - if(opts.call(t) == "[object Function]"){ - // non-trivial function method => attach its name - t.nom = name; - } - target[name] = t; - } - } - } - return target; - } - - function extend(source){ - declare.safeMixin(this.prototype, source); - return this; - } - - // chained constructor compatible with the legacy dojo.declare() - function chainedConstructor(bases, ctorSpecial){ - return function(){ - var a = arguments, args = a, a0 = a[0], f, i, m, - l = bases.length, preArgs; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) call two types of the preamble - if(ctorSpecial && (a0 && a0.preamble || this.preamble)){ - // full blown ritual - preArgs = new Array(bases.length); - // prepare parameters - preArgs[0] = a; - for(i = 0;;){ - // process the preamble of the 1st argument - a0 = a[0]; - if(a0){ - f = a0.preamble; - if(f){ - a = f.apply(this, a) || a; - } - } - // process the preamble of this class - f = bases[i].prototype; - f = f.hasOwnProperty("preamble") && f.preamble; - if(f){ - a = f.apply(this, a) || a; - } - // one peculiarity of the preamble: - // it is called if it is not needed, - // e.g., there is no constructor to call - // let's watch for the last constructor - // (see ticket #9795) - if(++i == l){ - break; - } - preArgs[i] = a; - } - } - // 2) call all non-trivial constructors using prepared arguments - for(i = l - 1; i >= 0; --i){ - f = bases[i]; - m = f._meta; - f = m ? m.ctor : f; - if(f){ - f.apply(this, preArgs ? preArgs[i] : a); - } - } - // 3) continue the original ritual: call the postscript - f = this.postscript; - if(f){ - f.apply(this, args); - } - }; - } - - - // chained constructor compatible with the legacy dojo.declare() - function singleConstructor(ctor, ctorSpecial){ - return function(){ - var a = arguments, t = a, a0 = a[0], f; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) call two types of the preamble - if(ctorSpecial){ - // full blown ritual - if(a0){ - // process the preamble of the 1st argument - f = a0.preamble; - if(f){ - t = f.apply(this, t) || t; - } - } - f = this.preamble; - if(f){ - // process the preamble of this class - f.apply(this, t); - // one peculiarity of the preamble: - // it is called even if it is not needed, - // e.g., there is no constructor to call - // let's watch for the last constructor - // (see ticket #9795) - } - } - // 2) call a constructor - if(ctor){ - ctor.apply(this, a); - } - // 3) continue the original ritual: call the postscript - f = this.postscript; - if(f){ - f.apply(this, a); - } - }; - } - - // plain vanilla constructor (can use inherited() to call its base constructor) - function simpleConstructor(bases){ - return function(){ - var a = arguments, i = 0, f, m; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) do not call the preamble - // 2) call the top constructor (it can use this.inherited()) - for(; f = bases[i]; ++i){ // intentional assignment - m = f._meta; - f = m ? m.ctor : f; - if(f){ - f.apply(this, a); - break; - } - } - // 3) call the postscript - f = this.postscript; - if(f){ - f.apply(this, a); - } - }; - } - - function chain(name, bases, reversed){ - return function(){ - var b, m, f, i = 0, step = 1; - if(reversed){ - i = bases.length - 1; - step = -1; - } - for(; b = bases[i]; i += step){ // intentional assignment - m = b._meta; - f = (m ? m.hidden : b.prototype)[name]; - if(f){ - f.apply(this, arguments); - } - } - }; - } - - // forceNew(ctor) - // return a new object that inherits from ctor.prototype but - // without actually running ctor on the object. - function forceNew(ctor){ - // create object with correct prototype using a do-nothing - // constructor - xtor.prototype = ctor.prototype; - var t = new xtor; - xtor.prototype = null; // clean up - return t; - } - - // applyNew(args) - // just like 'new ctor()' except that the constructor and its arguments come - // from args, which must be an array or an arguments object - function applyNew(args){ - // create an object with ctor's prototype but without - // calling ctor on it. - var ctor = args.callee, t = forceNew(ctor); - // execute the real constructor on the new object - ctor.apply(t, args); - return t; - } - - function declare(className, superclass, props){ - // crack parameters - if(typeof className != "string"){ - props = superclass; - superclass = className; - className = ""; - } - props = props || {}; - - var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass; - - // build a prototype - if(opts.call(superclass) == "[object Array]"){ - // C3 MRO - bases = c3mro(superclass, className); - t = bases[0]; - mixins = bases.length - t; - superclass = bases[mixins]; - }else{ - bases = [0]; - if(superclass){ - if(opts.call(superclass) == "[object Function]"){ - t = superclass._meta; - bases = bases.concat(t ? t.bases : superclass); - }else{ - err("base class is not a callable constructor.", className); - } - }else if(superclass !== null){ - err("unknown base class. Did you use dojo.require to pull it in?", className); - } - } - if(superclass){ - for(i = mixins - 1;; --i){ - proto = forceNew(superclass); - if(!i){ - // stop if nothing to add (the last base) - break; - } - // mix in properties - t = bases[i]; - (t._meta ? mixOwn : mix)(proto, t.prototype); - // chain in new constructor - ctor = new Function; - ctor.superclass = superclass; - ctor.prototype = proto; - superclass = proto.constructor = ctor; - } - }else{ - proto = {}; - } - // add all properties - declare.safeMixin(proto, props); - // add constructor - t = props.constructor; - if(t !== op.constructor){ - t.nom = cname; - proto.constructor = t; - } - - // collect chains and flags - for(i = mixins - 1; i; --i){ // intentional assignment - t = bases[i]._meta; - if(t && t.chains){ - chains = mix(chains || {}, t.chains); - } - } - if(proto["-chains-"]){ - chains = mix(chains || {}, proto["-chains-"]); - } - - // build ctor - t = !chains || !chains.hasOwnProperty(cname); - bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) : - (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t)); - - // add meta information to the constructor - ctor._meta = {bases: bases, hidden: props, chains: chains, - parents: parents, ctor: props.constructor}; - ctor.superclass = superclass && superclass.prototype; - ctor.extend = extend; - ctor.prototype = proto; - proto.constructor = ctor; - - // add "standard" methods to the prototype - proto.getInherited = getInherited; - proto.isInstanceOf = isInstanceOf; - proto.inherited = inheritedImpl; - proto.__inherited = inherited; - - // add name if specified - if(className){ - proto.declaredClass = className; - lang.setObject(className, ctor); - } - - // build chains and add them to the prototype - if(chains){ - for(name in chains){ - if(proto[name] && typeof chains[name] == "string" && name != cname){ - t = proto[name] = chain(name, bases, chains[name] === "after"); - t.nom = name; - } - } - } - // chained methods do not return values - // no need to chain "invisible" functions - - return ctor; // Function - } - - /*===== - dojo.declare = function(className, superclass, props){ - // summary: - // Create a feature-rich constructor from compact notation. - // className: String?: - // The optional name of the constructor (loosely, a "class") - // stored in the "declaredClass" property in the created prototype. - // It will be used as a global name for a created constructor. - // superclass: Function|Function[]: - // May be null, a Function, or an Array of Functions. This argument - // specifies a list of bases (the left-most one is the most deepest - // base). - // props: Object: - // An object whose properties are copied to the created prototype. - // Add an instance-initialization function by making it a property - // named "constructor". - // returns: - // New constructor function. - // description: - // Create a constructor using a compact notation for inheritance and - // prototype extension. - // - // Mixin ancestors provide a type of multiple inheritance. - // Prototypes of mixin ancestors are copied to the new class: - // changes to mixin prototypes will not affect classes to which - // they have been mixed in. - // - // Ancestors can be compound classes created by this version of - // dojo.declare. In complex cases all base classes are going to be - // linearized according to C3 MRO algorithm - // (see http://www.python.org/download/releases/2.3/mro/ for more - // details). - // - // "className" is cached in "declaredClass" property of the new class, - // if it was supplied. The immediate super class will be cached in - // "superclass" property of the new class. - // - // Methods in "props" will be copied and modified: "nom" property - // (the declared name of the method) will be added to all copied - // functions to help identify them for the internal machinery. Be - // very careful, while reusing methods: if you use the same - // function under different names, it can produce errors in some - // cases. - // - // It is possible to use constructors created "manually" (without - // dojo.declare) as bases. They will be called as usual during the - // creation of an instance, their methods will be chained, and even - // called by "this.inherited()". - // - // Special property "-chains-" governs how to chain methods. It is - // a dictionary, which uses method names as keys, and hint strings - // as values. If a hint string is "after", this method will be - // called after methods of its base classes. If a hint string is - // "before", this method will be called before methods of its base - // classes. - // - // If "constructor" is not mentioned in "-chains-" property, it will - // be chained using the legacy mode: using "after" chaining, - // calling preamble() method before each constructor, if available, - // and calling postscript() after all constructors were executed. - // If the hint is "after", it is chained as a regular method, but - // postscript() will be called after the chain of constructors. - // "constructor" cannot be chained "before", but it allows - // a special hint string: "manual", which means that constructors - // are not going to be chained in any way, and programmer will call - // them manually using this.inherited(). In the latter case - // postscript() will be called after the construction. - // - // All chaining hints are "inherited" from base classes and - // potentially can be overridden. Be very careful when overriding - // hints! Make sure that all chained methods can work in a proposed - // manner of chaining. - // - // Once a method was chained, it is impossible to unchain it. The - // only exception is "constructor". You don't need to define a - // method in order to supply a chaining hint. - // - // If a method is chained, it cannot use this.inherited() because - // all other methods in the hierarchy will be called automatically. - // - // Usually constructors and initializers of any kind are chained - // using "after" and destructors of any kind are chained as - // "before". Note that chaining assumes that chained methods do not - // return any value: any returned value will be discarded. - // - // example: - // | dojo.declare("my.classes.bar", my.classes.foo, { - // | // properties to be added to the class prototype - // | someValue: 2, - // | // initialization function - // | constructor: function(){ - // | this.myComplicatedObject = new ReallyComplicatedObject(); - // | }, - // | // other functions - // | someMethod: function(){ - // | doStuff(); - // | } - // | }); - // - // example: - // | var MyBase = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyClass1 = dojo.declare(MyBase, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyClass2 = dojo.declare(MyBase, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyDiamond = dojo.declare([MyClass1, MyClass2], { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // - // example: - // | var F = function(){ console.log("raw constructor"); }; - // | F.prototype.method = function(){ - // | console.log("raw method"); - // | }; - // | var A = dojo.declare(F, { - // | constructor: function(){ - // | console.log("A.constructor"); - // | }, - // | method: function(){ - // | console.log("before calling F.method..."); - // | this.inherited(arguments); - // | console.log("...back in A"); - // | } - // | }); - // | new A().method(); - // | // will print: - // | // raw constructor - // | // A.constructor - // | // before calling F.method... - // | // raw method - // | // ...back in A - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | destroy: "before" - // | } - // | }); - // | var B = dojo.declare(A, { - // | constructor: function(){ - // | console.log("B.constructor"); - // | }, - // | destroy: function(){ - // | console.log("B.destroy"); - // | } - // | }); - // | var C = dojo.declare(B, { - // | constructor: function(){ - // | console.log("C.constructor"); - // | }, - // | destroy: function(){ - // | console.log("C.destroy"); - // | } - // | }); - // | new C().destroy(); - // | // prints: - // | // B.constructor - // | // C.constructor - // | // C.destroy - // | // B.destroy - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | constructor: "manual" - // | } - // | }); - // | var B = dojo.declare(A, { - // | constructor: function(){ - // | // ... - // | // call the base constructor with new parameters - // | this.inherited(arguments, [1, 2, 3]); - // | // ... - // | } - // | }); - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | m1: "before" - // | }, - // | m1: function(){ - // | console.log("A.m1"); - // | }, - // | m2: function(){ - // | console.log("A.m2"); - // | } - // | }); - // | var B = dojo.declare(A, { - // | "-chains-": { - // | m2: "after" - // | }, - // | m1: function(){ - // | console.log("B.m1"); - // | }, - // | m2: function(){ - // | console.log("B.m2"); - // | } - // | }); - // | var x = new B(); - // | x.m1(); - // | // prints: - // | // B.m1 - // | // A.m1 - // | x.m2(); - // | // prints: - // | // A.m2 - // | // B.m2 - return new Function(); // Function - }; - =====*/ - - /*===== - dojo.safeMixin = function(target, source){ - // summary: - // Mix in properties skipping a constructor and decorating functions - // like it is done by dojo.declare. - // target: Object - // Target object to accept new properties. - // source: Object - // Source object for new properties. - // description: - // This function is used to mix in properties like lang.mixin does, - // but it skips a constructor property and decorates functions like - // dojo.declare does. - // - // It is meant to be used with classes and objects produced with - // dojo.declare. Functions mixed in with dojo.safeMixin can use - // this.inherited() like normal methods. - // - // This function is used to implement extend() method of a constructor - // produced with dojo.declare(). - // - // example: - // | var A = dojo.declare(null, { - // | m1: function(){ - // | console.log("A.m1"); - // | }, - // | m2: function(){ - // | console.log("A.m2"); - // | } - // | }); - // | var B = dojo.declare(A, { - // | m1: function(){ - // | this.inherited(arguments); - // | console.log("B.m1"); - // | } - // | }); - // | B.extend({ - // | m2: function(){ - // | this.inherited(arguments); - // | console.log("B.m2"); - // | } - // | }); - // | var x = new B(); - // | dojo.safeMixin(x, { - // | m1: function(){ - // | this.inherited(arguments); - // | console.log("X.m1"); - // | }, - // | m2: function(){ - // | this.inherited(arguments); - // | console.log("X.m2"); - // | } - // | }); - // | x.m2(); - // | // prints: - // | // A.m1 - // | // B.m1 - // | // X.m1 - }; - =====*/ - - /*===== - Object.inherited = function(name, args, newArgs){ - // summary: - // Calls a super method. - // name: String? - // The optional method name. Should be the same as the caller's - // name. Usually "name" is specified in complex dynamic cases, when - // the calling method was dynamically added, undecorated by - // dojo.declare, and it cannot be determined. - // args: Arguments - // The caller supply this argument, which should be the original - // "arguments". - // newArgs: Object? - // If "true", the found function will be returned without - // executing it. - // If Array, it will be used to call a super method. Otherwise - // "args" will be used. - // returns: - // Whatever is returned by a super method, or a super method itself, - // if "true" was specified as newArgs. - // description: - // This method is used inside method of classes produced with - // dojo.declare to call a super method (next in the chain). It is - // used for manually controlled chaining. Consider using the regular - // chaining, because it is faster. Use "this.inherited()" only in - // complex cases. - // - // This method cannot me called from automatically chained - // constructors including the case of a special (legacy) - // constructor chaining. It cannot be called from chained methods. - // - // If "this.inherited()" cannot find the next-in-chain method, it - // does nothing and returns "undefined". The last method in chain - // can be a default method implemented in Object, which will be - // called last. - // - // If "name" is specified, it is assumed that the method that - // received "args" is the parent method for this call. It is looked - // up in the chain list and if it is found the next-in-chain method - // is called. If it is not found, the first-in-chain method is - // called. - // - // If "name" is not specified, it will be derived from the calling - // method (using a methoid property "nom"). - // - // example: - // | var B = dojo.declare(A, { - // | method1: function(a, b, c){ - // | this.inherited(arguments); - // | }, - // | method2: function(a, b){ - // | return this.inherited(arguments, [a + b]); - // | } - // | }); - // | // next method is not in the chain list because it is added - // | // manually after the class was created. - // | B.prototype.method3 = function(){ - // | console.log("This is a dynamically-added method."); - // | this.inherited("method3", arguments); - // | }; - // example: - // | var B = dojo.declare(A, { - // | method: function(a, b){ - // | var super = this.inherited(arguments, true); - // | // ... - // | if(!super){ - // | console.log("there is no super method"); - // | return 0; - // | } - // | return super.apply(this, arguments); - // | } - // | }); - return {}; // Object - } - =====*/ - - /*===== - Object.getInherited = function(name, args){ - // summary: - // Returns a super method. - // name: String? - // The optional method name. Should be the same as the caller's - // name. Usually "name" is specified in complex dynamic cases, when - // the calling method was dynamically added, undecorated by - // dojo.declare, and it cannot be determined. - // args: Arguments - // The caller supply this argument, which should be the original - // "arguments". - // returns: - // Returns a super method (Function) or "undefined". - // description: - // This method is a convenience method for "this.inherited()". - // It uses the same algorithm but instead of executing a super - // method, it returns it, or "undefined" if not found. - // - // example: - // | var B = dojo.declare(A, { - // | method: function(a, b){ - // | var super = this.getInherited(arguments); - // | // ... - // | if(!super){ - // | console.log("there is no super method"); - // | return 0; - // | } - // | return super.apply(this, arguments); - // | } - // | }); - return {}; // Object - } - =====*/ - - /*===== - Object.isInstanceOf = function(cls){ - // summary: - // Checks the inheritance chain to see if it is inherited from this - // class. - // cls: Function - // Class constructor. - // returns: - // "true", if this object is inherited from this class, "false" - // otherwise. - // description: - // This method is used with instances of classes produced with - // dojo.declare to determine of they support a certain interface or - // not. It models "instanceof" operator. - // - // example: - // | var A = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var B = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var C = dojo.declare([A, B], { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var D = dojo.declare(A, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | - // | var a = new A(), b = new B(), c = new C(), d = new D(); - // | - // | console.log(a.isInstanceOf(A)); // true - // | console.log(b.isInstanceOf(A)); // false - // | console.log(c.isInstanceOf(A)); // true - // | console.log(d.isInstanceOf(A)); // true - // | - // | console.log(a.isInstanceOf(B)); // false - // | console.log(b.isInstanceOf(B)); // true - // | console.log(c.isInstanceOf(B)); // true - // | console.log(d.isInstanceOf(B)); // false - // | - // | console.log(a.isInstanceOf(C)); // false - // | console.log(b.isInstanceOf(C)); // false - // | console.log(c.isInstanceOf(C)); // true - // | console.log(d.isInstanceOf(C)); // false - // | - // | console.log(a.isInstanceOf(D)); // false - // | console.log(b.isInstanceOf(D)); // false - // | console.log(c.isInstanceOf(D)); // false - // | console.log(d.isInstanceOf(D)); // true - return {}; // Object - } - =====*/ - - /*===== - Object.extend = function(source){ - // summary: - // Adds all properties and methods of source to constructor's - // prototype, making them available to all instances created with - // constructor. This method is specific to constructors created with - // dojo.declare. - // source: Object - // Source object which properties are going to be copied to the - // constructor's prototype. - // description: - // Adds source properties to the constructor's prototype. It can - // override existing properties. - // - // This method is similar to dojo.extend function, but it is specific - // to constructors produced by dojo.declare. It is implemented - // using dojo.safeMixin, and it skips a constructor property, - // and properly decorates copied functions. - // - // example: - // | var A = dojo.declare(null, { - // | m1: function(){}, - // | s1: "Popokatepetl" - // | }); - // | A.extend({ - // | m1: function(){}, - // | m2: function(){}, - // | f1: true, - // | d1: 42 - // | }); - }; - =====*/ - - dojo.safeMixin = declare.safeMixin = safeMixin; - dojo.declare = declare; - - return declare; -}); diff --git a/lib/dojo/_base/event.js.uncompressed.js b/lib/dojo/_base/event.js.uncompressed.js deleted file mode 100644 index 34b9ce8e6..000000000 --- a/lib/dojo/_base/event.js.uncompressed.js +++ /dev/null @@ -1,51 +0,0 @@ -define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){ - // module: - // dojo/_base/event - // summary: - // This module defines dojo DOM event API. - if(on._fixEvent){ - var fixEvent = on._fixEvent; - on._fixEvent = function(evt, se){ - // add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive - evt = fixEvent(evt, se); - if(evt){ - dom.normalizeEvent(evt); - } - return evt; - }; - } - dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){ - // summary: - // normalizes properties on the event object including event - // bubbling methods, keystroke normalization, and x/y positions - // evt: Event - // native event object - // sender: DOMNode - // node to treat as "currentTarget" - if(on._fixEvent){ - return on._fixEvent(evt, sender); - } - return evt; // Event - }; - - dojo.stopEvent = function(/*Event*/ evt){ - // summary: - // prevents propagation and clobbers the default action of the - // passed event - // evt: Event - // The event object. If omitted, window.event is used on IE. - if(has("dom-addeventlistener") || (evt && evt.preventDefault)){ - evt.preventDefault(); - evt.stopPropagation(); - }else{ - evt = evt || window.event; - evt.cancelBubble = true; - on._preventDefault.call(evt); - } - }; - - return { - fix: dojo.fixEvent, - stop: dojo.stopEvent - }; -}); diff --git a/lib/dojo/_base/fx.js.uncompressed.js b/lib/dojo/_base/fx.js.uncompressed.js deleted file mode 100644 index cf52b0de1..000000000 --- a/lib/dojo/_base/fx.js.uncompressed.js +++ /dev/null @@ -1,666 +0,0 @@ -define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){ - // module: - // dojo/_base/fx - // summary: - // This module defines the base dojo.fx implementation. - // notes: - // Animation loosely package based on Dan Pupius' work, contributed under CLA; see - // http://pupius.co.uk/js/Toolkit.Drawing.js - - var _mixin = lang.mixin; - - dojo._Line = function(/*int*/ start, /*int*/ end){ - // summary: - // dojo._Line is the object used to generate values from a start value - // to an end value - // start: int - // Beginning value for range - // end: int - // Ending value for range - this.start = start; - this.end = end; - }; - - dojo._Line.prototype.getValue = function(/*float*/ n){ - // summary: Returns the point on the line - // n: a floating point number greater than 0 and less than 1 - return ((this.end - this.start) * n) + this.start; // Decimal - }; - - dojo.Animation = function(args){ - // summary: - // A generic animation class that fires callbacks into its handlers - // object at various states. - // description: - // A generic animation class that fires callbacks into its handlers - // object at various states. Nearly all dojo animation functions - // return an instance of this method, usually without calling the - // .play() method beforehand. Therefore, you will likely need to - // call .play() on instances of `dojo.Animation` when one is - // returned. - // args: Object - // The 'magic argument', mixing all the properties into this - // animation instance. - - _mixin(this, args); - if(lang.isArray(this.curve)){ - this.curve = new dojo._Line(this.curve[0], this.curve[1]); - } - - }; - dojo.Animation.prototype = new Evented(); - // Alias to drop come 2.0: - dojo._Animation = dojo.Animation; - - lang.extend(dojo.Animation, { - // duration: Integer - // The time in milliseonds the animation will take to run - duration: 350, - - /*===== - // curve: dojo._Line|Array - // A two element array of start and end values, or a `dojo._Line` instance to be - // used in the Animation. - curve: null, - - // easing: Function? - // A Function to adjust the acceleration (or deceleration) of the progress - // across a dojo._Line - easing: null, - =====*/ - - // repeat: Integer? - // The number of times to loop the animation - repeat: 0, - - // rate: Integer? - // the time in milliseconds to wait before advancing to next frame - // (used as a fps timer: 1000/rate = fps) - rate: 20 /* 50 fps */, - - /*===== - // delay: Integer? - // The time in milliseconds to wait before starting animation after it - // has been .play()'ed - delay: null, - - // beforeBegin: Event? - // Synthetic event fired before a dojo.Animation begins playing (synchronous) - beforeBegin: null, - - // onBegin: Event? - // Synthetic event fired as a dojo.Animation begins playing (useful?) - onBegin: null, - - // onAnimate: Event? - // Synthetic event fired at each interval of a `dojo.Animation` - onAnimate: null, - - // onEnd: Event? - // Synthetic event fired after the final frame of a `dojo.Animation` - onEnd: null, - - // onPlay: Event? - // Synthetic event fired any time a `dojo.Animation` is play()'ed - onPlay: null, - - // onPause: Event? - // Synthetic event fired when a `dojo.Animation` is paused - onPause: null, - - // onStop: Event - // Synthetic event fires when a `dojo.Animation` is stopped - onStop: null, - - =====*/ - - _percent: 0, - _startRepeatCount: 0, - - _getStep: function(){ - var _p = this._percent, - _e = this.easing - ; - return _e ? _e(_p) : _p; - }, - _fire: function(/*Event*/ evt, /*Array?*/ args){ - // summary: - // Convenience function. Fire event "evt" and pass it the - // arguments specified in "args". - // description: - // Convenience function. Fire event "evt" and pass it the - // arguments specified in "args". - // Fires the callback in the scope of the `dojo.Animation` - // instance. - // evt: - // The event to fire. - // args: - // The arguments to pass to the event. - var a = args||[]; - if(this[evt]){ - if(dojo.config.debugAtAllCosts){ - this[evt].apply(this, a); - }else{ - try{ - this[evt].apply(this, a); - }catch(e){ - // squelch and log because we shouldn't allow exceptions in - // synthetic event handlers to cause the internal timer to run - // amuck, potentially pegging the CPU. I'm not a fan of this - // squelch, but hopefully logging will make it clear what's - // going on - console.error("exception in animation handler for:", evt); - console.error(e); - } - } - } - return this; // dojo.Animation - }, - - play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){ - // summary: - // Start the animation. - // delay: - // How many milliseconds to delay before starting. - // gotoStart: - // If true, starts the animation from the beginning; otherwise, - // starts it from its current position. - // returns: dojo.Animation - // The instance to allow chaining. - - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - if(gotoStart){ - _t._stopTimer(); - _t._active = _t._paused = false; - _t._percent = 0; - }else if(_t._active && !_t._paused){ - return _t; - } - - _t._fire("beforeBegin", [_t.node]); - - var de = delay || _t.delay, - _p = lang.hitch(_t, "_play", gotoStart); - - if(de > 0){ - _t._delayTimer = setTimeout(_p, de); - return _t; - } - _p(); - return _t; // dojo.Animation - }, - - _play: function(gotoStart){ - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - _t._startTime = new Date().valueOf(); - if(_t._paused){ - _t._startTime -= _t.duration * _t._percent; - } - - _t._active = true; - _t._paused = false; - var value = _t.curve.getValue(_t._getStep()); - if(!_t._percent){ - if(!_t._startRepeatCount){ - _t._startRepeatCount = _t.repeat; - } - _t._fire("onBegin", [value]); - } - - _t._fire("onPlay", [value]); - - _t._cycle(); - return _t; // dojo.Animation - }, - - pause: function(){ - // summary: Pauses a running animation. - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - _t._stopTimer(); - if(!_t._active){ return _t; /*dojo.Animation*/ } - _t._paused = true; - _t._fire("onPause", [_t.curve.getValue(_t._getStep())]); - return _t; // dojo.Animation - }, - - gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){ - // summary: - // Sets the progress of the animation. - // percent: - // A percentage in decimal notation (between and including 0.0 and 1.0). - // andPlay: - // If true, play the animation after setting the progress. - var _t = this; - _t._stopTimer(); - _t._active = _t._paused = true; - _t._percent = percent; - if(andPlay){ _t.play(); } - return _t; // dojo.Animation - }, - - stop: function(/*boolean?*/ gotoEnd){ - // summary: Stops a running animation. - // gotoEnd: If true, the animation will end. - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - if(!_t._timer){ return _t; /* dojo.Animation */ } - _t._stopTimer(); - if(gotoEnd){ - _t._percent = 1; - } - _t._fire("onStop", [_t.curve.getValue(_t._getStep())]); - _t._active = _t._paused = false; - return _t; // dojo.Animation - }, - - status: function(){ - // summary: - // Returns a string token representation of the status of - // the animation, one of: "paused", "playing", "stopped" - if(this._active){ - return this._paused ? "paused" : "playing"; // String - } - return "stopped"; // String - }, - - _cycle: function(){ - var _t = this; - if(_t._active){ - var curr = new Date().valueOf(); - var step = (curr - _t._startTime) / (_t.duration); - - if(step >= 1){ - step = 1; - } - _t._percent = step; - - // Perform easing - if(_t.easing){ - step = _t.easing(step); - } - - _t._fire("onAnimate", [_t.curve.getValue(step)]); - - if(_t._percent < 1){ - _t._startTimer(); - }else{ - _t._active = false; - - if(_t.repeat > 0){ - _t.repeat--; - _t.play(null, true); - }else if(_t.repeat == -1){ - _t.play(null, true); - }else{ - if(_t._startRepeatCount){ - _t.repeat = _t._startRepeatCount; - _t._startRepeatCount = 0; - } - } - _t._percent = 0; - _t._fire("onEnd", [_t.node]); - !_t.repeat && _t._stopTimer(); - } - } - return _t; // dojo.Animation - }, - - _clearTimer: function(){ - // summary: Clear the play delay timer - clearTimeout(this._delayTimer); - delete this._delayTimer; - } - - }); - - // the local timer, stubbed into all Animation instances - var ctr = 0, - timer = null, - runner = { - run: function(){} - }; - - lang.extend(dojo.Animation, { - - _startTimer: function(){ - if(!this._timer){ - this._timer = connect.connect(runner, "run", this, "_cycle"); - ctr++; - } - if(!timer){ - timer = setInterval(lang.hitch(runner, "run"), this.rate); - } - }, - - _stopTimer: function(){ - if(this._timer){ - connect.disconnect(this._timer); - this._timer = null; - ctr--; - } - if(ctr <= 0){ - clearInterval(timer); - timer = null; - ctr = 0; - } - } - - }); - - var _makeFadeable = - has("ie") ? function(node){ - // only set the zoom if the "tickle" value would be the same as the - // default - var ns = node.style; - // don't set the width to auto if it didn't already cascade that way. - // We don't want to f anyones designs - if(!ns.width.length && style.get(node, "width") == "auto"){ - ns.width = "auto"; - } - } : - function(){}; - - dojo._fade = function(/*Object*/ args){ - // summary: - // Returns an animation that will fade the node defined by - // args.node from the start to end values passed (args.start - // args.end) (end is mandatory, start is optional) - - args.node = dom.byId(args.node); - var fArgs = _mixin({ properties: {} }, args), - props = (fArgs.properties.opacity = {}); - - props.start = !("start" in fArgs) ? - function(){ - return +style.get(fArgs.node, "opacity")||0; - } : fArgs.start; - props.end = fArgs.end; - - var anim = dojo.animateProperty(fArgs); - connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node)); - - return anim; // dojo.Animation - }; - - /*===== - dojo.__FadeArgs = function(node, duration, easing){ - // node: DOMNode|String - // The node referenced in the animation - // duration: Integer? - // Duration of the animation in milliseconds. - // easing: Function? - // An easing function. - this.node = node; - this.duration = duration; - this.easing = easing; - } - =====*/ - - dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){ - // summary: - // Returns an animation that will fade node defined in 'args' from - // its current opacity to fully opaque. - return dojo._fade(_mixin({ end: 1 }, args)); // dojo.Animation - }; - - dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){ - // summary: - // Returns an animation that will fade node defined in 'args' - // from its current opacity to fully transparent. - return dojo._fade(_mixin({ end: 0 }, args)); // dojo.Animation - }; - - dojo._defaultEasing = function(/*Decimal?*/ n){ - // summary: The default easing function for dojo.Animation(s) - return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2); // Decimal - }; - - var PropLine = function(properties){ - // PropLine is an internal class which is used to model the values of - // an a group of CSS properties across an animation lifecycle. In - // particular, the "getValue" function handles getting interpolated - // values between start and end for a particular CSS value. - this._properties = properties; - for(var p in properties){ - var prop = properties[p]; - if(prop.start instanceof Color){ - // create a reusable temp color object to keep intermediate results - prop.tempColor = new Color(); - } - } - }; - - PropLine.prototype.getValue = function(r){ - var ret = {}; - for(var p in this._properties){ - var prop = this._properties[p], - start = prop.start; - if(start instanceof Color){ - ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss(); - }else if(!lang.isArray(start)){ - ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0); - } - } - return ret; - }; - - /*===== - dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], { - // Properties: Object? - // A hash map of style properties to Objects describing the transition, - // such as the properties of dojo._Line with an additional 'units' property - properties: {} - - //TODOC: add event callbacks - }); - =====*/ - - dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){ - // summary: - // Returns an animation that will transition the properties of - // node defined in `args` depending how they are defined in - // `args.properties` - // - // description: - // `dojo.animateProperty` is the foundation of most `dojo.fx` - // animations. It takes an object of "properties" corresponding to - // style properties, and animates them in parallel over a set - // duration. - // - // example: - // A simple animation that changes the width of the specified node. - // | dojo.animateProperty({ - // | node: "nodeId", - // | properties: { width: 400 }, - // | }).play(); - // Dojo figures out the start value for the width and converts the - // integer specified for the width to the more expressive but - // verbose form `{ width: { end: '400', units: 'px' } }` which you - // can also specify directly. Defaults to 'px' if ommitted. - // - // example: - // Animate width, height, and padding over 2 seconds... the - // pedantic way: - // | dojo.animateProperty({ node: node, duration:2000, - // | properties: { - // | width: { start: '200', end: '400', units:"px" }, - // | height: { start:'200', end: '400', units:"px" }, - // | paddingTop: { start:'5', end:'50', units:"px" } - // | } - // | }).play(); - // Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties - // are written using "mixed case", as the hyphen is illegal as an object key. - // - // example: - // Plug in a different easing function and register a callback for - // when the animation ends. Easing functions accept values between - // zero and one and return a value on that basis. In this case, an - // exponential-in curve. - // | dojo.animateProperty({ - // | node: "nodeId", - // | // dojo figures out the start value - // | properties: { width: { end: 400 } }, - // | easing: function(n){ - // | return (n==0) ? 0 : Math.pow(2, 10 * (n - 1)); - // | }, - // | onEnd: function(node){ - // | // called when the animation finishes. The animation - // | // target is passed to this function - // | } - // | }).play(500); // delay playing half a second - // - // example: - // Like all `dojo.Animation`s, animateProperty returns a handle to the - // Animation instance, which fires the events common to Dojo FX. Use `dojo.connect` - // to access these events outside of the Animation definiton: - // | var anim = dojo.animateProperty({ - // | node:"someId", - // | properties:{ - // | width:400, height:500 - // | } - // | }); - // | dojo.connect(anim,"onEnd", function(){ - // | console.log("animation ended"); - // | }); - // | // play the animation now: - // | anim.play(); - // - // example: - // Each property can be a function whose return value is substituted along. - // Additionally, each measurement (eg: start, end) can be a function. The node - // reference is passed direcly to callbacks. - // | dojo.animateProperty({ - // | node:"mine", - // | properties:{ - // | height:function(node){ - // | // shrink this node by 50% - // | return dojo.position(node).h / 2 - // | }, - // | width:{ - // | start:function(node){ return 100; }, - // | end:function(node){ return 200; } - // | } - // | } - // | }).play(); - // - - var n = args.node = dom.byId(args.node); - if(!args.easing){ args.easing = dojo._defaultEasing; } - - var anim = new dojo.Animation(args); - connect.connect(anim, "beforeBegin", anim, function(){ - var pm = {}; - for(var p in this.properties){ - // Make shallow copy of properties into pm because we overwrite - // some values below. In particular if start/end are functions - // we don't want to overwrite them or the functions won't be - // called if the animation is reused. - if(p == "width" || p == "height"){ - this.node.display = "block"; - } - var prop = this.properties[p]; - if(lang.isFunction(prop)){ - prop = prop(n); - } - prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop })); - - if(lang.isFunction(prop.start)){ - prop.start = prop.start(n); - } - if(lang.isFunction(prop.end)){ - prop.end = prop.end(n); - } - var isColor = (p.toLowerCase().indexOf("color") >= 0); - function getStyle(node, p){ - // dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable: - var v = { height: node.offsetHeight, width: node.offsetWidth }[p]; - if(v !== undefined){ return v; } - v = style.get(node, p); - return (p == "opacity") ? +v : (isColor ? v : parseFloat(v)); - } - if(!("end" in prop)){ - prop.end = getStyle(n, p); - }else if(!("start" in prop)){ - prop.start = getStyle(n, p); - } - - if(isColor){ - prop.start = new Color(prop.start); - prop.end = new Color(prop.end); - }else{ - prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start); - } - } - this.curve = new PropLine(pm); - }); - connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node)); - return anim; // dojo.Animation - }; - - dojo.anim = function( /*DOMNode|String*/ node, - /*Object*/ properties, - /*Integer?*/ duration, - /*Function?*/ easing, - /*Function?*/ onEnd, - /*Integer?*/ delay){ - // summary: - // A simpler interface to `dojo.animateProperty()`, also returns - // an instance of `dojo.Animation` but begins the animation - // immediately, unlike nearly every other Dojo animation API. - // description: - // `dojo.anim` is a simpler (but somewhat less powerful) version - // of `dojo.animateProperty`. It uses defaults for many basic properties - // and allows for positional parameters to be used in place of the - // packed "property bag" which is used for other Dojo animation - // methods. - // - // The `dojo.Animation` object returned from `dojo.anim` will be - // already playing when it is returned from this function, so - // calling play() on it again is (usually) a no-op. - // node: - // a DOM node or the id of a node to animate CSS properties on - // duration: - // The number of milliseconds over which the animation - // should run. Defaults to the global animation default duration - // (350ms). - // easing: - // An easing function over which to calculate acceleration - // and deceleration of the animation through its duration. - // A default easing algorithm is provided, but you may - // plug in any you wish. A large selection of easing algorithms - // are available in `dojo.fx.easing`. - // onEnd: - // A function to be called when the animation finishes - // running. - // delay: - // The number of milliseconds to delay beginning the - // animation by. The default is 0. - // example: - // Fade out a node - // | dojo.anim("id", { opacity: 0 }); - // example: - // Fade out a node over a full second - // | dojo.anim("id", { opacity: 0 }, 1000); - return dojo.animateProperty({ // dojo.Animation - node: node, - duration: duration || dojo.Animation.prototype.duration, - properties: properties, - easing: easing, - onEnd: onEnd - }).play(delay || 0); - }; - - return { - _Line: dojo._Line, - Animation: dojo.Animation, - _fade: dojo._fade, - fadeIn: dojo.fadeIn, - fadeOut: dojo.fadeOut, - _defaultEasing: dojo._defaultEasing, - animateProperty: dojo.animateProperty, - anim: dojo.anim - }; -}); diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js deleted file mode 100644 index 63e3bee46..000000000 --- a/lib/dojo/_base/html.js.uncompressed.js +++ /dev/null @@ -1,389 +0,0 @@ -define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){ - // module: - // dojo/dom - // summary: - // This module is a stub for the core dojo DOM API. - - // mix-in dom - dojo.byId = dom.byId; - dojo.isDescendant = dom.isDescendant; - dojo.setSelectable = dom.setSelectable; - - // mix-in dom-attr - dojo.getAttr = attr.get; - dojo.setAttr = attr.set; - dojo.hasAttr = attr.has; - dojo.removeAttr = attr.remove; - dojo.getNodeProp = attr.getNodeProp; - - dojo.attr = function(node, name, value){ - // summary: - // Gets or sets an attribute on an HTML element. - // description: - // Handles normalized getting and setting of attributes on DOM - // Nodes. If 2 arguments are passed, and a the second argument is a - // string, acts as a getter. - // - // If a third argument is passed, or if the second argument is a - // map of attributes, acts as a setter. - // - // When passing functions as values, note that they will not be - // directly assigned to slots on the node, but rather the default - // behavior will be removed and the new behavior will be added - // using `dojo.connect()`, meaning that event handler properties - // will be normalized and that some caveats with regards to - // non-standard behaviors for onsubmit apply. Namely that you - // should cancel form submission using `dojo.stopEvent()` on the - // passed event object instead of returning a boolean value from - // the handler itself. - // node: DOMNode|String - // id or reference to the element to get or set the attribute on - // name: String|Object - // the name of the attribute to get or set. - // value: String? - // The value to set for the attribute - // returns: - // when used as a getter, the value of the requested attribute - // or null if that attribute does not have a specified or - // default value; - // - // when used as a setter, the DOM node - // - // example: - // | // get the current value of the "foo" attribute on a node - // | dojo.attr(dojo.byId("nodeId"), "foo"); - // | // or we can just pass the id: - // | dojo.attr("nodeId", "foo"); - // - // example: - // | // use attr() to set the tab index - // | dojo.attr("nodeId", "tabIndex", 3); - // | - // - // example: - // Set multiple values at once, including event handlers: - // | dojo.attr("formId", { - // | "foo": "bar", - // | "tabIndex": -1, - // | "method": "POST", - // | "onsubmit": function(e){ - // | // stop submitting the form. Note that the IE behavior - // | // of returning true or false will have no effect here - // | // since our handler is connect()ed to the built-in - // | // onsubmit behavior and so we need to use - // | // dojo.stopEvent() to ensure that the submission - // | // doesn't proceed. - // | dojo.stopEvent(e); - // | - // | // submit the form with Ajax - // | dojo.xhrPost({ form: "formId" }); - // | } - // | }); - // - // example: - // Style is s special case: Only set with an object hash of styles - // | dojo.attr("someNode",{ - // | id:"bar", - // | style:{ - // | width:"200px", height:"100px", color:"#000" - // | } - // | }); - // - // example: - // Again, only set style as an object hash of styles: - // | var obj = { color:"#fff", backgroundColor:"#000" }; - // | dojo.attr("someNode", "style", obj); - // | - // | // though shorter to use `dojo.style()` in this case: - // | dojo.style("someNode", obj); - - if(arguments.length == 2){ - return attr[typeof name == "string" ? "get" : "set"](node, name); - } - return attr.set(node, name, value); - }; - - // mix-in dom-class - dojo.hasClass = cls.contains; - dojo.addClass = cls.add; - dojo.removeClass = cls.remove; - dojo.toggleClass = cls.toggle; - dojo.replaceClass = cls.replace; - - // mix-in dom-construct - dojo._toDom = dojo.toDom = ctr.toDom; - dojo.place = ctr.place; - dojo.create = ctr.create; - dojo.empty = function(node){ ctr.empty(node); }; - dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); }; - - // mix-in dom-geometry - dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents; - dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents; - dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents; - dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents; - dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize; - dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox; - dojo.setMarginBox = geom.setMarginBox; - dojo._getContentBox = dojo.getContentBox = geom.getContentBox; - dojo.setContentSize = geom.setContentSize; - dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr; - dojo._docScroll = dojo.docScroll = geom.docScroll; - dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset; - dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft; - dojo.position = geom.position; - - dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){ - // summary: - // Getter/setter for the margin-box of node. - // description: - // Getter/setter for the margin-box of node. - // Returns an object in the expected format of box (regardless - // if box is passed). The object might look like: - // `{ l: 50, t: 200, w: 300: h: 150 }` - // for a node offset from its parent 50px to the left, 200px from - // the top with a margin width of 300px and a margin-height of - // 150px. - // node: - // id or reference to DOM Node to get/set box for - // box: - // If passed, denotes that dojo.marginBox() should - // update/set the margin box for node. Box is an object in the - // above format. All properties are optional if passed. - // example: - // Retrieve the margin box of a passed node - // | var box = dojo.marginBox("someNodeId"); - // | console.dir(box); - // - // example: - // Set a node's margin box to the size of another node - // | var box = dojo.marginBox("someNodeId"); - // | dojo.marginBox("someOtherNode", box); - return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object - }; - - dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){ - // summary: - // Getter/setter for the content-box of node. - // description: - // Returns an object in the expected format of box (regardless if box is passed). - // The object might look like: - // `{ l: 50, t: 200, w: 300: h: 150 }` - // for a node offset from its parent 50px to the left, 200px from - // the top with a content width of 300px and a content-height of - // 150px. Note that the content box may have a much larger border - // or margin box, depending on the box model currently in use and - // CSS values set/inherited for node. - // While the getter will return top and left values, the - // setter only accepts setting the width and height. - // node: - // id or reference to DOM Node to get/set box for - // box: - // If passed, denotes that dojo.contentBox() should - // update/set the content box for node. Box is an object in the - // above format, but only w (width) and h (height) are supported. - // All properties are optional if passed. - return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object - }; - - dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){ - // summary: - // Deprecated: Use position() for border-box x/y/w/h - // or marginBox() for margin-box w/h/l/t. - // Returns an object representing a node's size and position. - // - // description: - // Returns an object that measures margin-box (w)idth/(h)eight - // and absolute position x/y of the border-box. Also returned - // is computed (l)eft and (t)op values in pixels from the - // node's offsetParent as returned from marginBox(). - // Return value will be in the form: - //| { l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 } - // Does not act as a setter. If includeScroll is passed, the x and - // y params are affected as one would expect in dojo.position(). - dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox()."); - node = dom.byId(node); - var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s); - var abs = geom.position(node, includeScroll); - mb.x = abs.x; - mb.y = abs.y; - return mb; // Object - }; - - // mix-in dom-prop - dojo.getProp = prop.get; - dojo.setProp = prop.set; - - dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){ - // summary: - // Gets or sets a property on an HTML element. - // description: - // Handles normalized getting and setting of properties on DOM - // Nodes. If 2 arguments are passed, and a the second argument is a - // string, acts as a getter. - // - // If a third argument is passed, or if the second argument is a - // map of attributes, acts as a setter. - // - // When passing functions as values, note that they will not be - // directly assigned to slots on the node, but rather the default - // behavior will be removed and the new behavior will be added - // using `dojo.connect()`, meaning that event handler properties - // will be normalized and that some caveats with regards to - // non-standard behaviors for onsubmit apply. Namely that you - // should cancel form submission using `dojo.stopEvent()` on the - // passed event object instead of returning a boolean value from - // the handler itself. - // node: - // id or reference to the element to get or set the property on - // name: - // the name of the property to get or set. - // value: - // The value to set for the property - // returns: - // when used as a getter, the value of the requested property - // or null if that attribute does not have a specified or - // default value; - // - // when used as a setter, the DOM node - // - // example: - // | // get the current value of the "foo" property on a node - // | dojo.prop(dojo.byId("nodeId"), "foo"); - // | // or we can just pass the id: - // | dojo.prop("nodeId", "foo"); - // - // example: - // | // use prop() to set the tab index - // | dojo.prop("nodeId", "tabIndex", 3); - // | - // - // example: - // Set multiple values at once, including event handlers: - // | dojo.prop("formId", { - // | "foo": "bar", - // | "tabIndex": -1, - // | "method": "POST", - // | "onsubmit": function(e){ - // | // stop submitting the form. Note that the IE behavior - // | // of returning true or false will have no effect here - // | // since our handler is connect()ed to the built-in - // | // onsubmit behavior and so we need to use - // | // dojo.stopEvent() to ensure that the submission - // | // doesn't proceed. - // | dojo.stopEvent(e); - // | - // | // submit the form with Ajax - // | dojo.xhrPost({ form: "formId" }); - // | } - // | }); - // - // example: - // Style is s special case: Only set with an object hash of styles - // | dojo.prop("someNode",{ - // | id:"bar", - // | style:{ - // | width:"200px", height:"100px", color:"#000" - // | } - // | }); - // - // example: - // Again, only set style as an object hash of styles: - // | var obj = { color:"#fff", backgroundColor:"#000" }; - // | dojo.prop("someNode", "style", obj); - // | - // | // though shorter to use `dojo.style()` in this case: - // | dojo.style("someNode", obj); - - if(arguments.length == 2){ - return prop[typeof name == "string" ? "get" : "set"](node, name); - } - // setter - return prop.set(node, name, value); - }; - - // mix-in dom-style - dojo.getStyle = style.get; - dojo.setStyle = style.set; - dojo.getComputedStyle = style.getComputedStyle; - dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue; - - dojo.style = function(node, name, value){ - // summary: - // Accesses styles on a node. If 2 arguments are - // passed, acts as a getter. If 3 arguments are passed, acts - // as a setter. - // description: - // Getting the style value uses the computed style for the node, so the value - // will be a calculated value, not just the immediate node.style value. - // Also when getting values, use specific style names, - // like "borderBottomWidth" instead of "border" since compound values like - // "border" are not necessarily reflected as expected. - // If you want to get node dimensions, use `dojo.marginBox()`, - // `dojo.contentBox()` or `dojo.position()`. - // node: DOMNode|String - // id or reference to node to get/set style for - // name: String?|Object? - // the style property to set in DOM-accessor format - // ("borderWidth", not "border-width") or an object with key/value - // pairs suitable for setting each property. - // value: String? - // If passed, sets value on the node for style, handling - // cross-browser concerns. When setting a pixel value, - // be sure to include "px" in the value. For instance, top: "200px". - // Otherwise, in some cases, some browsers will not apply the style. - // returns: - // when used as a getter, return the computed style of the node if passing in an ID or node, - // or return the normalized, computed value for the property when passing in a node and a style property - // example: - // Passing only an ID or node returns the computed style object of - // the node: - // | dojo.style("thinger"); - // example: - // Passing a node and a style property returns the current - // normalized, computed value for that property: - // | dojo.style("thinger", "opacity"); // 1 by default - // - // example: - // Passing a node, a style property, and a value changes the - // current display of the node and returns the new computed value - // | dojo.style("thinger", "opacity", 0.5); // == 0.5 - // - // example: - // Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node: - // | dojo.style("thinger", { - // | "opacity": 0.5, - // | "border": "3px solid black", - // | "height": "300px" - // | }); - // - // example: - // When the CSS style property is hyphenated, the JavaScript property is camelCased. - // font-size becomes fontSize, and so on. - // | dojo.style("thinger",{ - // | fontSize:"14pt", - // | letterSpacing:"1.2em" - // | }); - // - // example: - // dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling - // dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()` - // | dojo.query(".someClassName").style("visibility","hidden"); - // | // or - // | dojo.query("#baz > div").style({ - // | opacity:0.75, - // | fontSize:"13pt" - // | }); - - switch(arguments.length){ - case 1: - return style.get(node); - case 2: - return style[typeof name == "string" ? "get" : "set"](node, name); - } - // setter - return style.set(node, name, value); - }; - - return dojo; -}); diff --git a/lib/dojo/_base/json.js.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js deleted file mode 100644 index b70d4ebb8..000000000 --- a/lib/dojo/_base/json.js.uncompressed.js +++ /dev/null @@ -1,85 +0,0 @@ -define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){ - // module: - // dojo/_base/json - // summary: - // This module defines the dojo JSON API. - -dojo.fromJson = function(/*String*/ js){ - // summary: - // Parses a JavaScript expression and returns a JavaScript value. - // description: - // Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It - // always delegates to eval(). The content passed to this method must therefore come - // from a trusted source. - // It is recommend that you use dojo/json's parse function for an - // implementation uses the (faster) native JSON parse when available. - // js: - // a string literal of a JavaScript expression, for instance: - // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'` - - return eval("(" + js + ")"); // Object -}; - -/*===== -dojo._escapeString = function(){ - // summary: - // Adds escape sequences for non-visual characters, double quote and - // backslash and surrounds with double quotes to form a valid string - // literal. -}; -=====*/ -dojo._escapeString = json.stringify; // just delegate to json.stringify - -dojo.toJsonIndentStr = "\t"; -dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){ - // 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 is recommend that you use dojo/json's stringify function for an lighter - // and faster implementation that matches the native JSON API and uses the - // native JSON serializer when available. - // 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. - // Note that in 1.6, toJson would serialize undefined, but this no longer supported - // since it is not supported by native JSON serializer. - // 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(). - // Note that if native JSON support is available, it will be used for serialization, - // and native implementations vary on the exact spacing used in pretty printing. - // returns: - // A JSON string serialization of the passed-in object. - // example: - // simple serialization of a trivial object - // | var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true }); - // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr); - // example: - // a custom serializer for an objects of a particular class: - // | dojo.declare("Furby", null, { - // | furbies: "are strange", - // | furbyCount: 10, - // | __json__: function(){ - // | }, - // | }); - - // use dojo/json - return json.stringify(it, function(key, value){ - if(value){ - var tf = value.__json__||value.json; - if(typeof tf == "function"){ - return tf.call(value); - } - } - return value; - }, prettyPrint && dojo.toJsonIndentStr); // String -}; - -return dojo; -}); diff --git a/lib/dojo/_base/kernel.js.uncompressed.js b/lib/dojo/_base/kernel.js.uncompressed.js deleted file mode 100644 index 30465dbb1..000000000 --- a/lib/dojo/_base/kernel.js.uncompressed.js +++ /dev/null @@ -1,302 +0,0 @@ -define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){ - // module: - // dojo/_base/kernel - // summary: - // This module is the foundational module of the dojo boot sequence; it defines the dojo object. - var - // loop variables for this module - i, p, - - // create dojo, dijit, and dojox - // FIXME: in 2.0 remove dijit, dojox being created by dojo - dijit = {}, - dojox = {}, - dojo = { - // notice dojo takes ownership of the value of the config module - config:config, - global:this, - dijit:dijit, - dojox:dojox - }; - - - // Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide - // a _scopeName property for the dojo, dijit, and dojox root object so those packages can create - // unique names in the global space. - // - // Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox, - // where global when in fact they are either global under different names or not global at all. In v1.6-, the - // config variable "scopeMap" was used to map names as used within a module to global names. This has been - // subsumed by the dojo packageMap configuration variable which relocates packages to different names. See - // http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details. - // - // The following computations contort the packageMap for this dojo instance into a scopeMap. - var scopeMap = - // a map from a name used in a legacy module to the (global variable name, object addressed by that name) - // always map dojo, dijit, and dojox - { - dojo:["dojo", dojo], - dijit:["dijit", dijit], - dojox:["dojox", dojox] - }, - - packageMap = - // the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config - (require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {}, - - item; - - // process all mapped top-level names for this instance of dojo - for(p in packageMap){ - if(scopeMap[p]){ - // mapped dojo, dijit, or dojox - scopeMap[p][0] = packageMap[p]; - }else{ - // some other top-level name - scopeMap[p] = [packageMap[p], {}]; - } - } - - // publish those names to _scopeName and, optionally, the global namespace - for(p in scopeMap){ - item = scopeMap[p]; - item[1]._scopeName = item[0]; - if(!config.noGlobals){ - this[item[0]] = item[1]; - } - } - dojo.scopeMap = scopeMap; - - // FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated - dojo.baseUrl = dojo.config.baseUrl = require.baseUrl; - dojo.isAsync = !1 || require.async; - dojo.locale = config.locale; - - /*===== - dojo.version = function(){ - // summary: - // Version number of the Dojo Toolkit - // major: Integer - // Major version. If total version is "1.2.0beta1", will be 1 - // minor: Integer - // Minor version. If total version is "1.2.0beta1", will be 2 - // patch: Integer - // Patch version. If total version is "1.2.0beta1", will be 0 - // flag: String - // Descriptor flag. If total version is "1.2.0beta1", will be "beta1" - // revision: Number - // The SVN rev from which dojo was pulled - this.major = 0; - this.minor = 0; - this.patch = 0; - this.flag = ""; - this.revision = 0; - } - =====*/ - var rev = "$Rev: 28982 $".match(/\d+/); - dojo.version = { - major: 1, minor: 7, patch: 3, flag: "", - revision: rev ? +rev[0] : NaN, - toString: function(){ - var v = dojo.version; - return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")"; // String - } - }; - - - // If 1 is truthy, then as a dojo module is defined it should push it's definitions - // into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object - // as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code - // is migrated. Absent specific advice otherwise, set extend-dojo to truthy. - true || has.add("extend-dojo", 1); - - - dojo.eval = function(scriptText){ - // summary: - // A legacy method created for use exclusively by internal Dojo methods. Do not use this method - // directly unless you understand its possibly-different implications on the platforms your are targeting. - // description: - // Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers - // that support indirect eval. - // - // As usual, IE does not. On IE, the only way to implement global eval is to - // use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval. - // This implementation uses the technique of executing eval in the scope of a function that is a single scope - // frame below the global scope; thereby coming close to the global scope. Note carefully that - // - // dojo.eval("var pi = 3.14;"); - // - // will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want - // to define a global variable using dojo.eval, write something like - // - // dojo.eval("window.pi = 3.14;") - // scriptText: - // The text to evaluation. - // returns: - // The result of the evaluation. Often `undefined` - }; - - (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo); - - - if(0){ - dojo.exit = function(exitcode){ - quit(exitcode); - }; - } else{ - dojo.exit = function(){ - }; - } - - true || has.add("dojo-guarantee-console", - // ensure that console.log, console.warn, etc. are defined - 1 - ); - if(1){ - typeof console != "undefined" || (console = {}); - // Be careful to leave 'log' always at the end - var cn = [ - "assert", "count", "debug", "dir", "dirxml", "error", "group", - "groupEnd", "info", "profile", "profileEnd", "time", "timeEnd", - "trace", "warn", "log" - ]; - var tn; - i = 0; - while((tn = cn[i++])){ - if(!console[tn]){ - (function(){ - var tcn = tn + ""; - console[tcn] = ('log' in console) ? function(){ - var a = Array.apply({}, arguments); - a.unshift(tcn + ":"); - console["log"](a.join(" ")); - } : function(){}; - console[tcn]._fake = true; - })(); - } - } - } - - has.add("dojo-debug-messages", - // include dojo.deprecated/dojo.experimental implementations - !!config.isDebug - ); - if(has("dojo-debug-messages")){ - dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){ - // summary: - // Log a debug message to indicate that a behavior has been - // deprecated. - // behaviour: String - // The API or behavior being deprecated. Usually in the form - // of "myApp.someFunction()". - // extra: String? - // Text to append to the message. Often provides advice on a - // new function or facility to achieve the same goal during - // the deprecation period. - // removal: String? - // Text to indicate when in the future the behavior will be - // removed. Usually a version number. - // example: - // | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0"); - - var message = "DEPRECATED: " + behaviour; - if(extra){ message += " " + extra; } - if(removal){ message += " -- will be removed in version: " + removal; } - console.warn(message); - }; - - dojo.experimental = function(/* String */ moduleName, /* String? */ extra){ - // summary: Marks code as experimental. - // description: - // This can be used to mark a function, file, or module as - // experimental. Experimental code is not ready to be used, and the - // APIs are subject to change without notice. Experimental code may be - // completed deleted without going through the normal deprecation - // process. - // moduleName: String - // The name of a module, or the name of a module file or a specific - // function - // extra: String? - // some additional message for the user - // example: - // | dojo.experimental("dojo.data.Result"); - // example: - // | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA"); - - var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice."; - if(extra){ message += " " + extra; } - console.warn(message); - }; - }else{ - dojo.deprecated = dojo.experimental = function(){}; - } - - true || has.add("dojo-modulePaths", - // consume dojo.modulePaths processing - 1 - ); - if(1){ - // notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run; - // this is the v1.6- behavior. - if(config.modulePaths){ - dojo.deprecated("dojo.modulePaths", "use paths configuration"); - var paths = {}; - for(p in config.modulePaths){ - paths[p.replace(/\./g, "/")] = config.modulePaths[p]; - } - require({paths:paths}); - } - } - - true || has.add("dojo-moduleUrl", - // include dojo.moduleUrl - 1 - ); - if(1){ - dojo.moduleUrl = function(/*String*/module, /*String?*/url){ - // summary: - // Returns a URL relative to a module. - // example: - // | var pngPath = dojo.moduleUrl("acme","images/small.png"); - // | console.dir(pngPath); // list the object properties - // | // create an image and set it's source to pngPath's value: - // | var img = document.createElement("img"); - // | img.src = pngPath; - // | // add our image to the document - // | dojo.body().appendChild(img); - // example: - // you may de-reference as far as you like down the package - // hierarchy. This is sometimes handy to avoid lenghty relative - // urls or for building portable sub-packages. In this example, - // the `acme.widget` and `acme.util` directories may be located - // under different roots (see `dojo.registerModulePath`) but the - // the modules which reference them can be unaware of their - // relative locations on the filesystem: - // | // somewhere in a configuration block - // | dojo.registerModulePath("acme.widget", "../../acme/widget"); - // | dojo.registerModulePath("acme.util", "../../util"); - // | - // | // ... - // | - // | // code in a module using acme resources - // | var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html"); - // | var dataPath = dojo.moduleUrl("acme.util","resources/data.json"); - - dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0"); - - // require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then - // remove the suffix from the result. This way clients can request a url w/out a filetype. This should be - // rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0). - // Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config. - var result = null; - if(module){ - result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/"); - } - return result; - }; - } - - dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling - - return dojo; -}); diff --git a/lib/dojo/_base/lang.js.uncompressed.js b/lib/dojo/_base/lang.js.uncompressed.js deleted file mode 100644 index 503606040..000000000 --- a/lib/dojo/_base/lang.js.uncompressed.js +++ /dev/null @@ -1,707 +0,0 @@ -define("dojo/_base/lang", ["./kernel", "../has", "./sniff"], function(dojo, has){ - // module: - // dojo/_base/lang - // summary: - // This module defines Javascript language extensions. - - has.add("bug-for-in-skips-shadowed", function(){ - // if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?) - for(var i in {toString: 1}){ - return 0; - } - return 1; - }); - - var _extraNames = - has("bug-for-in-skips-shadowed") ? - "hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [], - - _extraLen = _extraNames.length, - - _mixin = function(dest, source, copyFunc){ - var name, s, i, empty = {}; - for(name in source){ - // the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source" - // inherited from Object.prototype. For example, if dest has a custom toString() method, - // don't overwrite it with the toString() method that source inherited from Object.prototype - s = source[name]; - if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){ - dest[name] = copyFunc ? copyFunc(s) : s; - } - } - - if(has("bug-for-in-skips-shadowed")){ - if(source){ - for(i = 0; i < _extraLen; ++i){ - name = _extraNames[i]; - s = source[name]; - if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){ - dest[name] = copyFunc ? copyFunc(s) : s; - } - } - } - } - - return dest; // Object - }, - - mixin = function(dest, sources){ - if(!dest){ dest = {}; } - for(var i = 1, l = arguments.length; i < l; i++){ - lang._mixin(dest, arguments[i]); - } - return dest; // Object - }, - - getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){ - var p, i = 0, dojoGlobal = dojo.global; - if(!context){ - if(!parts.length){ - return dojoGlobal; - }else{ - p = parts[i++]; - try{ - context = dojo.scopeMap[p] && dojo.scopeMap[p][1]; - }catch(e){} - context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined)); - } - } - while(context && (p = parts[i++])){ - context = (p in context ? context[p] : (create ? context[p] = {} : undefined)); - } - return context; // mixed - }, - - setObject = function(name, value, context){ - var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context); - return obj && p ? (obj[p] = value) : undefined; // Object - }, - - getObject = function(name, create, context){ - return getProp(name.split("."), create, context); // Object - }, - - exists = function(name, obj){ - return lang.getObject(name, false, obj) !== undefined; // Boolean - }, - - opts = Object.prototype.toString, - - // Crockford (ish) functions - - isString = function(it){ - return (typeof it == "string" || it instanceof String); // Boolean - }, - - isArray = function(it){ - return it && (it instanceof Array || typeof it == "array"); // Boolean - }, - - isFunction = function(it){ - return opts.call(it) === "[object Function]"; - }, - - isObject = function(it){ - return it !== undefined && - (it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean - }, - - isArrayLike = function(it){ - return it && it !== undefined && // Boolean - // keep out built-in constructors (Number, String, ...) which have length - // properties - !lang.isString(it) && !lang.isFunction(it) && - !(it.tagName && it.tagName.toLowerCase() == 'form') && - (lang.isArray(it) || isFinite(it.length)); - }, - - isAlien = function(it){ - return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean - }, - - extend = function(constructor, props){ - for(var i=1, l=arguments.length; i<l; i++){ - lang._mixin(constructor.prototype, arguments[i]); - } - return constructor; // Object - }, - - _hitchArgs = function(scope, method){ - var pre = _toArray(arguments, 2); - var named = lang.isString(method); - return function(){ - // arrayify arguments - var args = _toArray(arguments); - // locate our method - var f = named ? (scope||dojo.global)[method] : method; - // invoke with collected args - return f && f.apply(scope || this, pre.concat(args)); // mixed - }; // Function - }, - - hitch = function(scope, method){ - if(arguments.length > 2){ - return lang._hitchArgs.apply(dojo, arguments); // Function - } - if(!method){ - method = scope; - scope = null; - } - if(lang.isString(method)){ - scope = scope || dojo.global; - if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); } - return function(){ return scope[method].apply(scope, arguments || []); }; // Function - } - return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function - }, - - delegate = (function(){ - // boodman/crockford delegation w/ cornford optimization - function TMP(){} - return function(obj, props){ - TMP.prototype = obj; - var tmp = new TMP(); - TMP.prototype = null; - if(props){ - lang._mixin(tmp, props); - } - return tmp; // Object - }; - })(), - - efficient = function(obj, offset, startWith){ - return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0)); - }, - - _toArray = - has("ie") ? - (function(){ - function slow(obj, offset, startWith){ - var arr = startWith||[]; - for(var x = offset || 0; x < obj.length; x++){ - arr.push(obj[x]); - } - return arr; - } - return function(obj){ - return ((obj.item) ? slow : efficient).apply(this, arguments); - }; - })() : efficient, - - partial = function(/*Function|String*/method /*, ...*/){ - var arr = [ null ]; - return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function - }, - - clone = function(/*anything*/ src){ - if(!src || typeof src != "object" || lang.isFunction(src)){ - // null, undefined, any non-object, or function - return src; // anything - } - if(src.nodeType && "cloneNode" in src){ - // DOM Node - return src.cloneNode(true); // Node - } - if(src instanceof Date){ - // Date - return new Date(src.getTime()); // Date - } - if(src instanceof RegExp){ - // RegExp - return new RegExp(src); // RegExp - } - var r, i, l; - if(lang.isArray(src)){ - // array - r = []; - for(i = 0, l = src.length; i < l; ++i){ - if(i in src){ - r.push(clone(src[i])); - } - } - // we don't clone functions for performance reasons - // }else if(d.isFunction(src)){ - // // function - // r = function(){ return src.apply(this, arguments); }; - }else{ - // generic objects - r = src.constructor ? new src.constructor() : {}; - } - return lang._mixin(r, src, clone); - }, - - - trim = String.prototype.trim ? - function(str){ return str.trim(); } : - function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); }, - - - _pattern = /\{([^\}]+)\}/g, - - replace = function(tmpl, map, pattern){ - return tmpl.replace(pattern || _pattern, lang.isFunction(map) ? - map : function(_, k){ return getObject(k, false, map); }); - }, - - lang = { - _extraNames:_extraNames, - _mixin:_mixin, - mixin:mixin, - setObject:setObject, - getObject:getObject, - exists:exists, - isString:isString, - isArray:isArray, - isFunction:isFunction, - isObject:isObject, - isArrayLike:isArrayLike, - isAlien:isAlien, - extend:extend, - _hitchArgs:_hitchArgs, - hitch:hitch, - delegate:delegate, - _toArray:_toArray, - partial:partial, - clone:clone, - trim:trim, - replace:replace - }; - - 1 && mixin(dojo, lang); - return lang; - - /*===== - dojo._extraNames - // summary: - // Array of strings. Lists property names that must be explicitly processed during for-in interation - // in environments that have has("bug-for-in-skips-shadowed") true. - =====*/ - - /*===== - dojo._mixin = function(dest, source, copyFunc){ - // summary: - // Copies/adds all properties of source to dest; returns dest. - // dest: Object: - // The object to which to copy/add all properties contained in source. - // source: Object: - // The object from which to draw all properties to copy into dest. - // copyFunc: Function?: - // The process used to copy/add a property in source; defaults to the Javascript assignment operator. - // returns: - // dest, as modified - // description: - // All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions - // found in Object.prototype, are copied/added to dest. Copying/adding each particular property is - // delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided. - // Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference. - } - =====*/ - - /*===== - dojo.mixin = function(dest, sources){ - // summary: - // Copies/adds all properties of one or more sources to dest; returns dest. - // dest: Object - // The object to which to copy/add all properties contained in source. If dest is falsy, then - // a new object is manufactured before copying/adding properties begins. - // sources: Object... - // One of more objects from which to draw all properties to copy into dest. sources are processed - // left-to-right and if more than one of these objects contain the same property name, the right-most - // value "wins". - // returns: Object - // dest, as modified - // description: - // All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions - // found in Object.prototype, are copied/added from sources to dest. sources are processed left to right. - // The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin - // executes a so-called "shallow copy" and aggregate types are copied/added by reference. - // example: - // make a shallow copy of an object - // | var copy = lang.mixin({}, source); - // example: - // many class constructors often take an object which specifies - // values to be configured on the object. In this case, it is - // often simplest to call `lang.mixin` on the `this` object: - // | dojo.declare("acme.Base", null, { - // | constructor: function(properties){ - // | // property configuration: - // | lang.mixin(this, properties); - // | - // | console.log(this.quip); - // | // ... - // | }, - // | quip: "I wasn't born yesterday, you know - I've seen movies.", - // | // ... - // | }); - // | - // | // create an instance of the class and configure it - // | var b = new acme.Base({quip: "That's what it does!" }); - // example: - // copy in properties from multiple objects - // | var flattened = lang.mixin( - // | { - // | name: "Frylock", - // | braces: true - // | }, - // | { - // | name: "Carl Brutanananadilewski" - // | } - // | ); - // | - // | // will print "Carl Brutanananadilewski" - // | console.log(flattened.name); - // | // will print "true" - // | console.log(flattened.braces); - } - =====*/ - - /*===== - dojo.setObject = function(name, value, context){ - // summary: - // Set a property from a dot-separated string, such as "A.B.C" - // description: - // Useful for longer api chains where you have to test each object in - // the chain, or when you have an object reference in string format. - // Objects are created as needed along `path`. Returns the passed - // value if setting is successful or `undefined` if not. - // name: String - // Path to a property, in the form "A.B.C". - // value: anything - // value or object to place at location given by name - // context: Object? - // Optional. Object to use as root of path. Defaults to - // `dojo.global`. - // example: - // set the value of `foo.bar.baz`, regardless of whether - // intermediate objects already exist: - // | lang.setObject("foo.bar.baz", value); - // example: - // without `lang.setObject`, we often see code like this: - // | // ensure that intermediate objects are available - // | if(!obj["parent"]){ obj.parent = {}; } - // | if(!obj.parent["child"]){ obj.parent.child = {}; } - // | // now we can safely set the property - // | obj.parent.child.prop = "some value"; - // whereas with `lang.setObject`, we can shorten that to: - // | lang.setObject("parent.child.prop", "some value", obj); - } - =====*/ - - /*===== - dojo.getObject = function(name, create, context){ - // summary: - // Get a property from a dot-separated string, such as "A.B.C" - // description: - // Useful for longer api chains where you have to test each object in - // the chain, or when you have an object reference in string format. - // name: String - // Path to an property, in the form "A.B.C". - // create: Boolean? - // Optional. Defaults to `false`. If `true`, Objects will be - // created at any point along the 'path' that is undefined. - // context: Object? - // Optional. Object to use as root of path. Defaults to - // 'dojo.global'. Null may be passed. - } - =====*/ - - /*===== - dojo.exists = function(name, obj){ - // summary: - // determine if an object supports a given method - // description: - // useful for longer api chains where you have to test each object in - // the chain. Useful for object and method detection. - // name: String - // Path to an object, in the form "A.B.C". - // obj: Object? - // Object to use as root of path. Defaults to - // 'dojo.global'. Null may be passed. - // example: - // | // define an object - // | var foo = { - // | bar: { } - // | }; - // | - // | // search the global scope - // | lang.exists("foo.bar"); // true - // | lang.exists("foo.bar.baz"); // false - // | - // | // search from a particular scope - // | lang.exists("bar", foo); // true - // | lang.exists("bar.baz", foo); // false - } - =====*/ - - /*===== - dojo.isString = function(it){ - // summary: - // Return true if it is a String - // it: anything - // Item to test. - } - =====*/ - - /*===== - dojo.isArray = function(it){ - // summary: - // Return true if it is an Array. - // Does not work on Arrays created in other windows. - // it: anything - // Item to test. - } - =====*/ - - /*===== - dojo.isFunction = function(it){ - // summary: - // Return true if it is a Function - // it: anything - // Item to test. - } - =====*/ - - /*===== - dojo.isObject = function(it){ - // summary: - // Returns true if it is a JavaScript object (or an Array, a Function - // or null) - // it: anything - // Item to test. - } - =====*/ - - /*===== - dojo.isArrayLike = function(it){ - // summary: - // similar to dojo.isArray() but more permissive - // it: anything - // Item to test. - // returns: - // If it walks like a duck and quacks like a duck, return `true` - // description: - // Doesn't strongly test for "arrayness". Instead, settles for "isn't - // a string or number and has a length property". Arguments objects - // and DOM collections will return true when passed to - // dojo.isArrayLike(), but will return false when passed to - // dojo.isArray(). - } - =====*/ - - /*===== - dojo.isAlien = function(it){ - // summary: - // Returns true if it is a built-in function or some other kind of - // oddball that *should* report as a function but doesn't - } - =====*/ - - /*===== - dojo.extend = function(constructor, props){ - // summary: - // Adds all properties and methods of props to constructor's - // prototype, making them available to all instances created with - // constructor. - // constructor: Object - // Target constructor to extend. - // props: Object... - // One or more objects to mix into constructor.prototype - } - =====*/ - - /*===== - dojo.hitch = function(scope, method){ - // summary: - // Returns a function that will only ever execute in the a given scope. - // This allows for easy use of object member functions - // in callbacks and other places in which the "this" keyword may - // otherwise not reference the expected scope. - // Any number of default positional arguments may be passed as parameters - // beyond "method". - // Each of these values will be used to "placehold" (similar to curry) - // for the hitched function. - // scope: Object - // The scope to use when method executes. If method is a string, - // scope is also the object containing method. - // method: Function|String... - // A function to be hitched to scope, or the name of the method in - // scope to be hitched. - // example: - // | dojo.hitch(foo, "bar")(); - // runs foo.bar() in the scope of foo - // example: - // | dojo.hitch(foo, myFunction); - // returns a function that runs myFunction in the scope of foo - // example: - // Expansion on the default positional arguments passed along from - // hitch. Passed args are mixed first, additional args after. - // | var foo = { bar: function(a, b, c){ console.log(a, b, c); } }; - // | var fn = dojo.hitch(foo, "bar", 1, 2); - // | fn(3); // logs "1, 2, 3" - // example: - // | var foo = { bar: 2 }; - // | dojo.hitch(foo, function(){ this.bar = 10; })(); - // execute an anonymous function in scope of foo - } - =====*/ - - /*===== - dojo.delegate = function(obj, props){ - // summary: - // Returns a new object which "looks" to obj for properties which it - // does not have a value for. Optionally takes a bag of properties to - // seed the returned object with initially. - // description: - // This is a small implementaton of the Boodman/Crockford delegation - // pattern in JavaScript. An intermediate object constructor mediates - // the prototype chain for the returned object, using it to delegate - // down to obj for property lookup when object-local lookup fails. - // This can be thought of similarly to ES4's "wrap", save that it does - // not act on types but rather on pure objects. - // obj: Object - // The object to delegate to for properties not found directly on the - // return object or in props. - // props: Object... - // an object containing properties to assign to the returned object - // returns: - // an Object of anonymous type - // example: - // | var foo = { bar: "baz" }; - // | var thinger = dojo.delegate(foo, { thud: "xyzzy"}); - // | thinger.bar == "baz"; // delegated to foo - // | foo.thud == undefined; // by definition - // | thinger.thud == "xyzzy"; // mixed in from props - // | foo.bar = "thonk"; - // | thinger.bar == "thonk"; // still delegated to foo's bar - } - =====*/ - - /*===== - dojo.partial = function(method){ - // summary: - // similar to hitch() except that the scope object is left to be - // whatever the execution context eventually becomes. - // method: Function|String - // description: - // Calling dojo.partial is the functional equivalent of calling: - // | dojo.hitch(null, funcName, ...); - } - =====*/ - - /*===== - dojo.trim = function(str){ - // summary: - // Trims whitespace from both sides of the string - // str: String - // String to be trimmed - // returns: String - // Returns the trimmed string - // description: - // This version of trim() was selected for inclusion into the base due - // to its compact size and relatively good performance - // (see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript) - // Uses String.prototype.trim instead, if available. - // The fastest but longest version of this function is located at - // dojo.string.trim() - } - =====*/ - - /*===== - dojo.clone = function(src){ - // summary: - // Clones objects (including DOM nodes) and all children. - // Warning: do not clone cyclic structures. - // src: - // The object to clone - } - =====*/ - - /*===== - dojo._toArray = function(obj, offset, startWith){ - // summary: - // Converts an array-like object (i.e. arguments, DOMCollection) to an - // array. Returns a new Array with the elements of obj. - // obj: Object - // the object to "arrayify". We expect the object to have, at a - // minimum, a length property which corresponds to integer-indexed - // properties. - // offset: Number? - // the location in obj to start iterating from. Defaults to 0. - // Optional. - // startWith: Array? - // An array to pack with the properties of obj. If provided, - // properties in obj are appended at the end of startWith and - // startWith is the returned array. - } - =====*/ - - /*===== - dojo.replace = function(tmpl, map, pattern){ - // summary: - // Performs parameterized substitutions on a string. Throws an - // exception if any parameter is unmatched. - // tmpl: String - // String to be used as a template. - // map: Object|Function - // If an object, it is used as a dictionary to look up substitutions. - // If a function, it is called for every substitution with following - // parameters: a whole match, a name, an offset, and the whole template - // string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace - // for more details). - // pattern: RegEx? - // Optional regular expression objects that overrides the default pattern. - // Must be global and match one item. The default is: /\{([^\}]+)\}/g, - // which matches patterns like that: "{xxx}", where "xxx" is any sequence - // of characters, which doesn't include "}". - // returns: String - // Returns the substituted string. - // example: - // | // uses a dictionary for substitutions: - // | dojo.replace("Hello, {name.first} {name.last} AKA {nick}!", - // | { - // | nick: "Bob", - // | name: { - // | first: "Robert", - // | middle: "X", - // | last: "Cringely" - // | } - // | }); - // | // returns: Hello, Robert Cringely AKA Bob! - // example: - // | // uses an array for substitutions: - // | dojo.replace("Hello, {0} {2}!", - // | ["Robert", "X", "Cringely"]); - // | // returns: Hello, Robert Cringely! - // example: - // | // uses a function for substitutions: - // | function sum(a){ - // | var t = 0; - // | dojo.forEach(a, function(x){ t += x; }); - // | return t; - // | } - // | dojo.replace( - // | "{count} payments averaging {avg} USD per payment.", - // | dojo.hitch( - // | { payments: [11, 16, 12] }, - // | function(_, key){ - // | switch(key){ - // | case "count": return this.payments.length; - // | case "min": return Math.min.apply(Math, this.payments); - // | case "max": return Math.max.apply(Math, this.payments); - // | case "sum": return sum(this.payments); - // | case "avg": return sum(this.payments) / this.payments.length; - // | } - // | } - // | ) - // | ); - // | // prints: 3 payments averaging 13 USD per payment. - // example: - // | // uses an alternative PHP-like pattern for substitutions: - // | dojo.replace("Hello, ${0} ${2}!", - // | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g); - // | // returns: Hello, Robert Cringely! - return ""; // String - } - =====*/ -}); - diff --git a/lib/dojo/_base/loader.js.uncompressed.js b/lib/dojo/_base/loader.js.uncompressed.js deleted file mode 100644 index 0bc2cc5b3..000000000 --- a/lib/dojo/_base/loader.js.uncompressed.js +++ /dev/null @@ -1,718 +0,0 @@ -define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) { - // module: - // dojo/_base/lader - // summary: - // This module defines the v1.x synchronous loader API. - - // signal the loader in sync mode... - //>>pure-amd - - if (!1){ - console.error("cannot load the Dojo v1.x loader with a foreign loader"); - return 0; - } - - var makeErrorToken = function(id){ - return {src:thisModule.id, id:id}; - }, - - slashName = function(name){ - return name.replace(/\./g, "/"); - }, - - buildDetectRe = /\/\/>>built/, - - dojoRequireCallbacks = [], - dojoRequireModuleStack = [], - - dojoRequirePlugin = function(mid, require, loaded){ - dojoRequireCallbacks.push(loaded); - array.forEach(mid.split(","), function(mid){ - var module = getModule(mid, require.module); - dojoRequireModuleStack.push(module); - injectModule(module); - }); - checkDojoRequirePlugin(); - }, - - // checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require!<module-list> dependency - // to see if they have arrived. The loader does not release *any* of these modules to be instantiated - // until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's - // that reference modules that are not available. - // - // The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees) - // of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!). - // The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all - // modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted - // directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then - // *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module" - // is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module". - // - // Note: inserting a dojo/require!<some-module-list> dependency in the dojoRequireModuleStack achieves nothing - // with the current algorithm; however, having such modules present makes it possible to optimize the algorithm - // - // Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies - // individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles - // and plugins. However, it is possible to reattach that strategy in the future. - - // a set from module-id to {undefined | 1 | 0}, where... - // undefined => the module has not been inspected - // 0 => the module or at least one of its dependencies has not arrived - // 1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume - // OK until proven otherwise), or has been completely traversed and all dependencies have arrived - touched, - - traverse = function(m){ - touched[m.mid] = 1; - for(var t, module, deps = m.deps || [], i= 0; i<deps.length; i++){ - module = deps[i]; - if(!(t = touched[module.mid])){ - if(t===0 || !traverse(module)){ - touched[m.mid] = 0; - return false; - } - } - } - return true; - }, - - checkDojoRequirePlugin = function(){ - // initialize the touched hash with easy-to-compute values that help short circuit recursive algorithm; - // recall loadInit/require plugin modules are dependencies of modules in dojoRequireModuleStack... - // which would cause a circular dependency chain that would never be resolved if checked here - // notice all dependencies of any particular loadInit/require plugin module will already - // be checked since those are pushed into dojoRequireModuleStack explicitly by the - // plugin...so if a particular loadInitPlugin module's dependencies are not really - // on board, that *will* be detected elsewhere in the traversal. - var module, mid; - touched = {}; - for(mid in modules){ - module = modules[mid]; - // this could be improved by remembering the result of the regex tests - if(module.executed || module.noReqPluginCheck){ - touched[mid] = 1; - }else{ - if(module.noReqPluginCheck!==0){ - // tag the module as either a loadInit or require plugin or not for future reference - module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0; - } - if(module.noReqPluginCheck){ - touched[mid] = 1; - }else if(module.injected!==arrived){ - // not executed, has not arrived, and is not a loadInit or require plugin resource - touched[mid] = 0; - }// else, leave undefined and we'll traverse the dependencies - } - } - - for(var t, i = 0, end = dojoRequireModuleStack.length; i<end; i++){ - module = dojoRequireModuleStack[i]; - if(!(t = touched[module.mid])){ - if(t===0 || !traverse(module)){ - return; - } - } - } - loaderVars.holdIdle(); - var oldCallbacks = dojoRequireCallbacks; - dojoRequireCallbacks = []; - array.forEach(oldCallbacks, function(cb){cb(1);}); - loaderVars.releaseIdle(); - }, - - dojoLoadInitPlugin = function(mid, require, loaded){ - // mid names a module that defines a "dojo load init" bundle, an object with two properties: - // - // * names: a vector of module ids that give top-level names to define in the lexical scope of def - // * def: a function that contains some some legacy loader API applications - // - // The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module - // ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit - // and dojo/require plugins. - // - // // dojox/gfx: - // - // define("*loadInit_12, { - // names:["dojo", "dijit", "dojox"], - // def: function(){ - // dojo.loadInit(function(){ - // var gfx = lang.getObject("dojox.gfx", true); - // - // // - // // code required to set gfx properties ommitted... - // // - // - // // now use the calculations to include the runtime-dependent module - // dojo.require("dojox.gfx." + gfx.renderer); - // }); - // } - // }); - // - // define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){ - // // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed: - // // "dojox.gfx." + gfx.renderer - // // dojox.gfx.matrix - // // dojox.gfx._base - // dojo.provide("dojo.gfx"); - // dojo.require("dojox.gfx.matrix"); - // dojo.require("dojox.gfx._base"); - // dojo.require("dojox.gfx." + gfx.renderer); - // return lang.getObject("dojo.gfx"); - // }); - // })(); - // - // The idea is to run the legacy loader API with global variables shadowed, which allows these variables to - // be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will - // execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded - // the plugin resource). - // - // Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time. - // - // Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in - // v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the - // same in the converted AMD module. - require([mid], function(bundle){ - // notice how names is resolved with respect to the module that demanded the plugin resource - require(bundle.names, function(){ - // bring the bundle names into scope - for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){ - scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; "; - args.push(arguments[i]); - } - eval(scopeText); - - var callingModule = require.module, - deps = [], - hold = {}, - requireList = [], - p, - syncLoaderApi = { - provide:function(moduleName){ - // mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected - moduleName = slashName(moduleName); - var providedModule = getModule(moduleName, callingModule); - if(providedModule!==callingModule){ - setArrived(providedModule); - } - }, - require:function(moduleName, omitModuleCheck){ - moduleName = slashName(moduleName); - omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule); - requireList.push(moduleName); - }, - requireLocalization:function(moduleName, bundleName, locale){ - // since we're going to need dojo/i8n, add it to deps if not already there - deps.length || (deps = ["dojo/i18n"]); - - // figure out if the bundle is xdomain; if so, add it to the depsSet - locale = (locale || dojo.locale).toLowerCase(); - moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName); - if(getModule(moduleName, callingModule).isXd){ - deps.push("dojo/i18n!" + moduleName); - }// else the bundle will be loaded synchronously when the module is evaluated - }, - loadInit:function(f){ - f(); - } - }; - - // hijack the correct dojo and apply bundle.def - try{ - for(p in syncLoaderApi){ - hold[p] = dojo[p]; - dojo[p] = syncLoaderApi[p]; - } - bundle.def.apply(null, args); - }catch(e){ - signal("error", [makeErrorToken("failedDojoLoadInit"), e]); - }finally{ - for(p in syncLoaderApi){ - dojo[p] = hold[p]; - } - } - - // requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed - requireList.length && deps.push("dojo/require!" + requireList.join(",")); - - dojoRequireCallbacks.push(loaded); - array.forEach(requireList, function(mid){ - var module = getModule(mid, require.module); - dojoRequireModuleStack.push(module); - injectModule(module); - }); - checkDojoRequirePlugin(); - }); - }); - }, - - extractApplication = function( - text, // the text to search - startSearch, // the position in text to start looking for the closing paren - startApplication // the position in text where the function application expression starts - ){ - // find end of the call by finding the matching end paren - // Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments - var parenRe = /\(|\)/g, - matchCount = 1, - match; - parenRe.lastIndex = startSearch; - while((match = parenRe.exec(text))){ - if(match[0] == ")"){ - matchCount -= 1; - }else{ - matchCount += 1; - } - if(matchCount == 0){ - break; - } - } - - if(matchCount != 0){ - throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text; - } - - //Put the master matching string in the results. - return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex]; - }, - - // the following regex is taken from 1.6. It is a very poor technique to remove comments and - // will fail in some cases; for example, consider the code... - // - // var message = "Category-1 */* Category-2"; - // - // The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all - // kinds of cases like this with strings and regexs that will cause this design to fail miserably. - // - // Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases. - // The only solution guaranteed 100% correct is to parse the code and that seems overkill for this - // backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it. - // See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further. - removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg, - - syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg, - - amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m, - - extractLegacyApiApplications = function(text, noCommentText){ - // scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is - // used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications - // to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return - // loadInitApplications + otherApplications. Fixup text by replacing - // - // dojo.loadInit(// etc... - // - // with - // - // \n 0 && dojo.loadInit(// etc... - // - // Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the - // code from an over-agressive removeCommentRe. However... - // - // WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application - // that is not in a comment. - - var match, startSearch, startApplication, application, - loadInitApplications = [], - otherApplications = [], - allApplications = []; - - // noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully) - noCommentText = noCommentText || text.replace(removeCommentRe, function(match){ - // remove iff the detected comment has text that looks like a sync loader API application; this helps by - // removing as little as possible, minimizing the changes the janky regex will kill the module - syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0; - return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match; - }); - - // find and extract all dojo.loadInit applications - while((match = syncLoaderApiRe.exec(noCommentText))){ - startSearch = syncLoaderApiRe.lastIndex; - startApplication = startSearch - match[0].length; - application = extractApplication(noCommentText, startSearch, startApplication); - if(match[2]=="loadInit"){ - loadInitApplications.push(application[0]); - }else{ - otherApplications.push(application[0]); - } - syncLoaderApiRe.lastIndex = application[1]; - } - allApplications = loadInitApplications.concat(otherApplications); - if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){ - // either there were some legacy loader API applications or there were no AMD API applications - return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications]; - }else{ - // legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module - return 0; - } - }, - - transformToAmd = function(module, text){ - // This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo - // module in terms of AMD define instead of creating the dojo proprietary xdomain module expression. - // The module could have originated from several sources: - // - // * amd require() a module, e.g., require(["my/module"]) - // * amd require() a nonmodule, e.g., require(["my/resource.js"') - // * amd define() deps vector (always a module) - // * dojo.require() a module, e.g. dojo.require("my.module") - // * dojo.require() a nonmodule, e.g., dojo.require("my.module", true) - // * dojo.requireIf/requireAfterIf/platformRequire a module - // - // The module is scanned for legacy loader API applications; if none are found, then assume the module is an - // AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text - // is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit - // plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's - // (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or - // dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus, - // when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed - // loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby - // following the synchronous code path. - - var extractResult, id, names = [], namesAsStrings = []; - if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){ - // buildDetectRe.test(text) => a built module, always AMD - // extractResult==0 => no sync API - return 0; - } - - // manufacture a synthetic module id that can never be a real mdule id (just like require does) - id = module.mid + "-*loadInit"; - - // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name - // the dojo/loadInit plugin assumes the first name in names is "dojo" - - for(var p in getModule("dojo", module).result.scopeMap){ - names.push(p); - namesAsStrings.push('"' + p + '"'); - } - - // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource - return "// xdomain rewrite of " + module.path + "\n" + - "define('" + id + "',{\n" + - "\tnames:" + dojo.toJson(names) + ",\n" + - "\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" + - "});\n\n" + - "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});"; - }, - - loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd), - - sync = - loaderVars.sync, - - xd = - loaderVars.xd, - - arrived = - loaderVars.arrived, - - nonmodule = - loaderVars.nonmodule, - - executing = - loaderVars.executing, - - executed = - loaderVars.executed, - - syncExecStack = - loaderVars.syncExecStack, - - modules = - loaderVars.modules, - - execQ = - loaderVars.execQ, - - getModule = - loaderVars.getModule, - - injectModule = - loaderVars.injectModule, - - setArrived = - loaderVars.setArrived, - - signal = - loaderVars.signal, - - finishExec = - loaderVars.finishExec, - - execModule = - loaderVars.execModule, - - getLegacyMode = - loaderVars.getLegacyMode; - - dojo.provide = function(mid){ - var executingModule = syncExecStack[0], - module = lang.mixin(getModule(slashName(mid), require.module), { - executed:executing, - result:lang.getObject(mid, true) - }); - setArrived(module); - if(executingModule){ - (executingModule.provides || (executingModule.provides = [])).push(function(){ - module.result = lang.getObject(mid); - delete module.provides; - module.executed!==executed && finishExec(module); - }); - }// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace - return module.result; - }; - - has.add("config-publishRequireResult", 1, 0, 0); - - dojo.require = function(moduleName, omitModuleCheck) { - // summary: - // loads a Javascript module from the appropriate URI - // - // moduleName: String - // module name to load, using periods for separators, - // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's - // internal mapping of locations to names and are disambiguated by - // longest prefix. See `dojo.registerModulePath()` for details on - // registering new modules. - // - // omitModuleCheck: Boolean? - // if `true`, omitModuleCheck skips the step of ensuring that the - // loaded file actually defines the symbol it is referenced by. - // For example if it called as `dojo.require("a.b.c")` and the - // file located at `a/b/c.js` does not define an object `a.b.c`, - // and exception will be throws whereas no exception is raised - // when called as `dojo.require("a.b.c", true)` - // - // description: - // Modules are loaded via dojo.require by using one of two loaders: the normal loader - // and the xdomain loader. The xdomain loader is used when dojo was built with a - // custom build that specified loader=xdomain and the module lives on a modulePath - // that is a whole URL, with protocol and a domain. The versions of Dojo that are on - // the Google and AOL CDNs use the xdomain loader. - // - // If the module is loaded via the xdomain loader, it is an asynchronous load, since - // the module is added via a dynamically created script tag. This - // means that dojo.require() can return before the module has loaded. However, this - // should only happen in the case where you do dojo.require calls in the top-level - // HTML page, or if you purposely avoid the loader checking for dojo.require - // dependencies in your module by using a syntax like dojo["require"] to load the module. - // - // Sometimes it is useful to not have the loader detect the dojo.require calls in the - // module so that you can dynamically load the modules as a result of an action on the - // page, instead of right at module load time. - // - // Also, for script blocks in an HTML page, the loader does not pre-process them, so - // it does not know to download the modules before the dojo.require calls occur. - // - // So, in those two cases, when you want on-the-fly module loading or for script blocks - // in the HTML page, special care must be taken if the dojo.required code is loaded - // asynchronously. To make sure you can execute code that depends on the dojo.required - // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad() - // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before - // executing. - // - // This type of syntax works with both xdomain and normal loaders, so it is good - // practice to always use this idiom for on-the-fly code loading and in HTML script - // blocks. If at some point you change loaders and where the code is loaded from, - // it will all still work. - // - // More on how dojo.require - // `dojo.require("A.B")` first checks to see if symbol A.B is - // defined. If it is, it is simply returned (nothing to do). - // - // If it is not defined, it will look for `A/B.js` in the script root - // directory. - // - // `dojo.require` throws an exception if it cannot find a file - // to load, or if the symbol `A.B` is not defined after loading. - // - // It returns the object `A.B`, but note the caveats above about on-the-fly loading and - // HTML script blocks when the xdomain loader is loading a module. - // - // `dojo.require()` does nothing about importing symbols into - // the current namespace. It is presumed that the caller will - // take care of that. - // - // example: - // To use dojo.require in conjunction with dojo.ready: - // - // | dojo.require("foo"); - // | dojo.require("bar"); - // | dojo.addOnLoad(function(){ - // | //you can now safely do something with foo and bar - // | }); - // - // example: - // For example, to import all symbols into a local block, you might write: - // - // | with (dojo.require("A.B")) { - // | ... - // | } - // - // And to import just the leaf symbol to a local variable: - // - // | var B = dojo.require("A.B"); - // | ... - // - // returns: - // the required namespace object - function doRequire(mid, omitModuleCheck){ - var module = getModule(slashName(mid), require.module); - if(syncExecStack.length && syncExecStack[0].finish){ - // switched to async loading in the middle of evaluating a legacy module; stop - // applying dojo.require so the remaining dojo.requires are applied in order - syncExecStack[0].finish.push(mid); - return undefined; - } - - // recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed - if(module.executed){ - return module.result; - } - omitModuleCheck && (module.result = nonmodule); - - var currentMode = getLegacyMode(); - - // recall, in sync mode to inject is to *eval* the module text - // if the module is a legacy module, this is the same as executing - // but if the module is an AMD module, this means defining, not executing - injectModule(module); - // the inject may have changed the mode - currentMode = getLegacyMode(); - - // in sync mode to dojo.require is to execute - if(module.executed!==executed && module.injected===arrived){ - // the module was already here before injectModule was called probably finishing up a xdomain - // load, but maybe a module given to the loader directly rather than having the loader retrieve it - loaderVars.holdIdle(); - execModule(module); - loaderVars.releaseIdle(); - } - if(module.executed){ - return module.result; - } - - if(currentMode==sync){ - // the only way to get here is in sync mode and dojo.required a module that - // * was loaded async in the injectModule application a few lines up - // * was an AMD module that had deps that are being loaded async and therefore couldn't execute - if(module.cjs){ - // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top - execQ.unshift(module); - }else{ - // the module was a legacy module - syncExecStack.length && (syncExecStack[0].finish= [mid]); - } - }else{ - // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting - // the module value synchronously; make sure it gets executed though - execQ.push(module); - } - return undefined; - } - - var result = doRequire(moduleName, omitModuleCheck); - if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){ - lang.setObject(moduleName, result); - } - return result; - }; - - dojo.loadInit = function(f) { - f(); - }; - - dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){ - // summary: - // Maps a module name to a path - // description: - // An unregistered module is given the default path of ../[module], - // relative to Dojo root. For example, module acme is mapped to - // ../acme. If you want to use a different module name, use - // dojo.registerModulePath. - // example: - // If your dojo.js is located at this location in the web root: - // | /myapp/js/dojo/dojo/dojo.js - // and your modules are located at: - // | /myapp/js/foo/bar.js - // | /myapp/js/foo/baz.js - // | /myapp/js/foo/thud/xyzzy.js - // Your application can tell Dojo to locate the "foo" namespace by calling: - // | dojo.registerModulePath("foo", "../../foo"); - // At which point you can then use dojo.require() to load the - // modules (assuming they provide() the same things which are - // required). The full code might be: - // | <script type="text/javascript" - // | src="/myapp/js/dojo/dojo/dojo.js"></script> - // | <script type="text/javascript"> - // | dojo.registerModulePath("foo", "../../foo"); - // | dojo.require("foo.bar"); - // | dojo.require("foo.baz"); - // | dojo.require("foo.thud.xyzzy"); - // | </script> - - var paths = {}; - paths[moduleName.replace(/\./g, "/")] = prefix; - require({paths:paths}); - }; - - dojo.platformRequire = function(/*Object*/modMap){ - // summary: - // require one or more modules based on which host environment - // Dojo is currently operating in - // description: - // This method takes a "map" of arrays which one can use to - // optionally load dojo modules. The map is indexed by the - // possible dojo.name_ values, with two additional values: - // "default" and "common". The items in the "default" array will - // be loaded if none of the other items have been choosen based on - // dojo.name_, set by your host environment. The items in the - // "common" array will *always* be loaded, regardless of which - // list is chosen. - // example: - // | dojo.platformRequire({ - // | browser: [ - // | "foo.sample", // simple module - // | "foo.test", - // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require) - // | ], - // | default: [ "foo.sample._base" ], - // | common: [ "important.module.common" ] - // | }); - - var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []), - temp; - while(result.length){ - if(lang.isArray(temp = result.shift())){ - dojo.require.apply(dojo, temp); - }else{ - dojo.require(temp); - } - } - }; - - dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){ - // summary: - // If the condition is true then call `dojo.require()` for the specified - // resource - // - // example: - // | dojo.requireIf(dojo.isBrowser, "my.special.Module"); - - if(condition){ - dojo.require(moduleName, omitModuleCheck); - } - }; - - dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){ - require(["../i18n"], function(i18n){ - i18n.getLocalization(moduleName, bundleName, locale); - }); - }; - - return { - extractLegacyApiApplications:extractLegacyApiApplications, - require:loaderVars.dojoRequirePlugin, - loadInit:dojoLoadInitPlugin - }; -}); diff --git a/lib/dojo/_base/query.js.uncompressed.js b/lib/dojo/_base/query.js.uncompressed.js deleted file mode 100644 index a1b161b0b..000000000 --- a/lib/dojo/_base/query.js.uncompressed.js +++ /dev/null @@ -1,3 +0,0 @@ -define("dojo/_base/query", ["./kernel", "../query", "./NodeList"], function(dojo){ - return dojo.query; -}); diff --git a/lib/dojo/_base/sniff.js.uncompressed.js b/lib/dojo/_base/sniff.js.uncompressed.js deleted file mode 100644 index c7e4b428a..000000000 --- a/lib/dojo/_base/sniff.js.uncompressed.js +++ /dev/null @@ -1,187 +0,0 @@ -define("dojo/_base/sniff", ["./kernel", "../has"], function(dojo, has){ - // module: - // dojo/sniff - // summary: - // This module populates the dojo browser version sniffing properties. - - if(!1){ - return has; - } - - dojo.isBrowser = true, - dojo._name = "browser"; - - var hasAdd = has.add, - n = navigator, - dua = n.userAgent, - dav = n.appVersion, - tv = parseFloat(dav), - isOpera, - isAIR, - isKhtml, - isWebKit, - isChrome, - isMac, - isSafari, - isMozilla , - isMoz, - isIE, - isFF, - isQuirks, - isIos, - isAndroid, - isWii; - - /*===== - dojo.isBrowser = { - // example: - // | if(dojo.isBrowser){ ... } - }; - - dojo.isFF = { - // example: - // | if(dojo.isFF > 1){ ... } - }; - - dojo.isIE = { - // example: - // | if(dojo.isIE > 6){ - // | // we are IE7 - // | } - }; - - dojo.isSafari = { - // example: - // | if(dojo.isSafari){ ... } - // example: - // Detect iPhone: - // | if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){ - // | // we are iPhone. Note, iPod touch reports "iPod" above and fails this test. - // | } - }; - - dojo.mixin(dojo, { - // isBrowser: Boolean - // True if the client is a web-browser - isBrowser: true, - // isFF: Number | undefined - // Version as a Number if client is FireFox. undefined otherwise. Corresponds to - // major detected FireFox version (1.5, 2, 3, etc.) - isFF: 2, - // isIE: Number | undefined - // Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to - // major detected IE version (6, 7, 8, etc.) - isIE: 6, - // isKhtml: Number | undefined - // Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major - // detected version. - isKhtml: 0, - // isWebKit: Number | undefined - // Version as a Number if client is a WebKit-derived browser (Konqueror, - // Safari, Chrome, etc.). undefined otherwise. - isWebKit: 0, - // isMozilla: Number | undefined - // Version as a Number if client is a Mozilla-based browser (Firefox, - // SeaMonkey). undefined otherwise. Corresponds to major detected version. - isMozilla: 0, - // isOpera: Number | undefined - // Version as a Number if client is Opera. undefined otherwise. Corresponds to - // major detected version. - isOpera: 0, - // isSafari: Number | undefined - // Version as a Number if client is Safari or iPhone. undefined otherwise. - isSafari: 0, - // isChrome: Number | undefined - // Version as a Number if client is Chrome browser. undefined otherwise. - isChrome: 0, - // isMac: Boolean - // True if the client runs on Mac - isMac: 0, - // isIos: Boolean - // True if client is iPhone, iPod, or iPad - isIos: 0, - // isAndroid: Number | undefined - // Version as a Number if client is android browser. undefined otherwise. - isAndroid: 0, - // isWii: Boolean - // True if client is Wii - isWii: 0 - }); - =====*/ - - // fill in the rendering support information in dojo.render.* - if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; } - isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0; - isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined; - isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined; - isMac = dav.indexOf("Macintosh") >= 0; - isIos = /iPhone|iPod|iPad/.test(dua); - isAndroid = parseFloat(dua.split("Android ")[1]) || undefined; - isWii = typeof opera != "undefined" && opera.wiiremote; - - // safari detection derived from: - // http://developer.apple.com/internet/safari/faq.html#anchor2 - // http://developer.apple.com/internet/safari/uamatrix.html - var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0); - if(index && !isChrome){ - // try to grab the explicit Safari version first. If we don't get - // one, look for less than 419.3 as the indication that we're on something - // "Safari 2-ish". - isSafari = parseFloat(dav.split("Version/")[1]); - if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){ - isSafari = 2; - } - } - - if (!has("dojo-webkit")) { - if(dua.indexOf("Opera") >= 0){ - isOpera = tv; - // see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/ - // 9.8 has both styles; <9.8, 9.9 only old style - if(isOpera >= 9.8){ - isOpera = parseFloat(dua.split("Version/")[1]) || tv; - } - } - - if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){ - isMozilla = isMoz = tv; - } - if(isMoz){ - //We really need to get away from this. Consider a sane isGecko approach for the future. - isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined; - } - if(document.all && !isOpera){ - isIE = parseFloat(dav.split("MSIE ")[1]) || undefined; - //In cases where the page has an HTTP header or META tag with - //X-UA-Compatible, then it is in emulation mode. - //Make sure isIE reflects the desired version. - //document.documentMode of 5 means quirks mode. - //Only switch the value if documentMode's major version - //is different from isIE's major version. - var mode = document.documentMode; - if(mode && mode != 5 && Math.floor(isIE) != mode){ - isIE = mode; - } - } - } - - isQuirks = document.compatMode == "BackCompat"; - - hasAdd("opera", dojo.isOpera = isOpera); - hasAdd("air", dojo.isAIR = isAIR); - hasAdd("khtml", dojo.isKhtml = isKhtml); - hasAdd("webkit", dojo.isWebKit = isWebKit); - hasAdd("chrome", dojo.isChrome = isChrome); - hasAdd("mac", dojo.isMac = isMac ); - hasAdd("safari", dojo.isSafari = isSafari); - hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla ); - hasAdd("ie", dojo.isIE = isIE ); - hasAdd("ff", dojo.isFF = isFF); - hasAdd("quirks", dojo.isQuirks = isQuirks); - hasAdd("ios", dojo.isIos = isIos); - hasAdd("android", dojo.isAndroid = isAndroid); - - dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase(); - - return has; -}); diff --git a/lib/dojo/_base/unload.js.uncompressed.js b/lib/dojo/_base/unload.js.uncompressed.js deleted file mode 100644 index e811d929d..000000000 --- a/lib/dojo/_base/unload.js.uncompressed.js +++ /dev/null @@ -1,81 +0,0 @@ -define("dojo/_base/unload", ["./kernel", "./connect"], function(dojo, connect) { - // module: - // dojo/unload - // summary: - // This module contains the document and window unload detection API. - - var win = window; - - /*===== - dojo.windowUnloaded = function(){ - // summary: - // signal fired by impending window destruction. You may use - // dojo.addOnWindowUnload() to register a listener for this - // event. NOTE: if you wish to dojo.connect() to this method - // to perform page/application cleanup, be aware that this - // event WILL NOT fire if no handler has been registered with - // dojo.addOnWindowUnload. This behavior started in Dojo 1.3. - // Previous versions always triggered dojo.windowUnloaded. See - // dojo.addOnWindowUnload for more info. - }; - =====*/ - - dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ - // summary: - // registers a function to be triggered when window.onunload - // fires. - // description: - // The first time that addOnWindowUnload is called Dojo - // will register a page listener to trigger your unload - // handler with. Note that registering these handlers may - // destory "fastback" page caching in browsers that support - // it. Be careful trying to modify the DOM or access - // JavaScript properties during this phase of page unloading: - // they may not always be available. Consider - // dojo.addOnUnload() if you need to modify the DOM or do - // heavy JavaScript work since it fires at the eqivalent of - // the page's "onbeforeunload" event. - // example: - // | dojo.addOnWindowUnload(functionPointer) - // | dojo.addOnWindowUnload(object, "functionName"); - // | dojo.addOnWindowUnload(object, function(){ /* ... */}); - - if (!dojo.windowUnloaded) { - connect.connect(win, "unload", (dojo.windowUnloaded= function(){})); - } - connect.connect(win, "unload", obj, functionName); - }; - - dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ - // summary: - // registers a function to be triggered when the page unloads. - // description: - // The first time that addOnUnload is called Dojo will - // register a page listener to trigger your unload handler - // with. - // - // In a browser enviroment, the functions will be triggered - // during the window.onbeforeunload event. Be careful of doing - // too much work in an unload handler. onbeforeunload can be - // triggered if a link to download a file is clicked, or if - // the link is a javascript: link. In these cases, the - // onbeforeunload event fires, but the document is not - // actually destroyed. So be careful about doing destructive - // operations in a dojo.addOnUnload callback. - // - // Further note that calling dojo.addOnUnload will prevent - // browsers from using a "fast back" cache to make page - // loading via back button instantaneous. - // example: - // | dojo.addOnUnload(functionPointer) - // | dojo.addOnUnload(object, "functionName") - // | dojo.addOnUnload(object, function(){ /* ... */}); - - connect.connect(win, "beforeunload", obj, functionName); - }; - - return { - addOnWindowUnload: dojo.addOnWindowUnload, - addOnUnload: dojo.addOnUnload - }; -}); diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js deleted file mode 100644 index 73f447b54..000000000 --- a/lib/dojo/_base/url.js.uncompressed.js +++ /dev/null @@ -1,111 +0,0 @@ -define("dojo/_base/url", ["./kernel"], function(dojo) { - // module: - // dojo/url - // summary: - // This module contains dojo._Url - - var - ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"), - ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"), - _Url = function(){ - var n = null, - _a = arguments, - uri = [_a[0]]; - // resolve uri components relative to each other - for(var i = 1; i<_a.length; i++){ - if(!_a[i]){ continue; } - - // Safari doesn't support this.constructor so we have to be explicit - // FIXME: Tracked (and fixed) in Webkit bug 3537. - // http://bugs.webkit.org/show_bug.cgi?id=3537 - var relobj = new _Url(_a[i]+""), - uriobj = new _Url(uri[0]+""); - - if( - relobj.path == "" && - !relobj.scheme && - !relobj.authority && - !relobj.query - ){ - if(relobj.fragment != n){ - uriobj.fragment = relobj.fragment; - } - relobj = uriobj; - }else if(!relobj.scheme){ - relobj.scheme = uriobj.scheme; - - if(!relobj.authority){ - relobj.authority = uriobj.authority; - - if(relobj.path.charAt(0) != "/"){ - var path = uriobj.path.substring(0, - uriobj.path.lastIndexOf("/") + 1) + relobj.path; - - var segs = path.split("/"); - for(var j = 0; j < segs.length; j++){ - if(segs[j] == "."){ - // flatten "./" references - if(j == segs.length - 1){ - segs[j] = ""; - }else{ - segs.splice(j, 1); - j--; - } - }else if(j > 0 && !(j == 1 && segs[0] == "") && - segs[j] == ".." && segs[j-1] != ".."){ - // flatten "../" references - if(j == (segs.length - 1)){ - segs.splice(j, 1); - segs[j - 1] = ""; - }else{ - segs.splice(j - 1, 2); - j -= 2; - } - } - } - relobj.path = segs.join("/"); - } - } - } - - uri = []; - if(relobj.scheme){ - uri.push(relobj.scheme, ":"); - } - if(relobj.authority){ - uri.push("//", relobj.authority); - } - uri.push(relobj.path); - if(relobj.query){ - uri.push("?", relobj.query); - } - if(relobj.fragment){ - uri.push("#", relobj.fragment); - } - } - - this.uri = uri.join(""); - - // break the uri into its main components - var r = this.uri.match(ore); - - this.scheme = r[2] || (r[1] ? "" : n); - this.authority = r[4] || (r[3] ? "" : n); - this.path = r[5]; // can never be undefined - this.query = r[7] || (r[6] ? "" : n); - this.fragment = r[9] || (r[8] ? "" : n); - - if(this.authority != n){ - // server based naming authority - r = this.authority.match(ire); - - this.user = r[3] || n; - this.password = r[4] || n; - this.host = r[6] || r[7]; // ipv6 || ipv4 - this.port = r[9] || n; - } - }; - _Url.prototype.toString = function(){ return this.uri; }; - - return dojo._Url = _Url; -}); diff --git a/lib/dojo/_base/window.js.uncompressed.js b/lib/dojo/_base/window.js.uncompressed.js deleted file mode 100644 index 0c9f236b6..000000000 --- a/lib/dojo/_base/window.js.uncompressed.js +++ /dev/null @@ -1,126 +0,0 @@ -define("dojo/_base/window", ["./kernel", "../has", "./sniff"], function(dojo, has){ - // module: - // dojo/window - // summary: - // This module provides an API to save/set/restore the global/document scope. - -/*===== -dojo.doc = { - // summary: - // Alias for the current document. 'dojo.doc' can be modified - // for temporary context shifting. Also see dojo.withDoc(). - // description: - // Refer to dojo.doc rather - // than referring to 'window.document' to ensure your code runs - // correctly in managed contexts. - // example: - // | n.appendChild(dojo.doc.createElement('div')); -} -=====*/ -dojo.doc = this["document"] || null; - -dojo.body = function(){ - // summary: - // Return the body element of the document - // return the body object associated with dojo.doc - // example: - // | dojo.body().appendChild(dojo.doc.createElement('div')); - - // Note: document.body is not defined for a strict xhtml document - // Would like to memoize this, but dojo.doc can change vi dojo.withDoc(). - return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node -}; - -dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){ - // summary: - // changes the behavior of many core Dojo functions that deal with - // namespace and DOM lookup, changing them to work in a new global - // context (e.g., an iframe). The varibles dojo.global and dojo.doc - // are modified as a result of calling this function and the result of - // `dojo.body()` likewise differs. - dojo.global = ret.global = globalObject; - dojo.doc = ret.doc = globalDocument; -}; - -dojo.withGlobal = function( /*Object*/globalObject, - /*Function*/callback, - /*Object?*/thisObject, - /*Array?*/cbArguments){ - // summary: - // Invoke callback with globalObject as dojo.global and - // globalObject.document as dojo.doc. - // description: - // Invoke callback with globalObject as dojo.global and - // globalObject.document as dojo.doc. If provided, globalObject - // will be executed in the context of object thisObject - // When callback() returns or throws an error, the dojo.global - // and dojo.doc will be restored to its previous state. - - var oldGlob = dojo.global; - try{ - dojo.global = ret.global = globalObject; - return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments); - }finally{ - dojo.global = ret.global = oldGlob; - } -}; - -dojo.withDoc = function( /*DocumentElement*/documentObject, - /*Function*/callback, - /*Object?*/thisObject, - /*Array?*/cbArguments){ - // summary: - // Invoke callback with documentObject as dojo.doc. - // description: - // Invoke callback with documentObject as dojo.doc. If provided, - // callback will be executed in the context of object thisObject - // When callback() returns or throws an error, the dojo.doc will - // be restored to its previous state. - - var oldDoc = dojo.doc, - oldQ = dojo.isQuirks, - oldIE = dojo.isIE, isIE, mode, pwin; - - try{ - dojo.doc = ret.doc = documentObject; - // update dojo.isQuirks and the value of the has feature "quirks" - dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only - - if(has("ie")){ - if((pwin = documentObject.parentWindow) && pwin.navigator){ - // re-run IE detection logic and update dojo.isIE / has("ie") - // (the only time parentWindow/navigator wouldn't exist is if we were not - // passed an actual legitimate document object) - isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined; - mode = documentObject.documentMode; - if(mode && mode != 5 && Math.floor(isIE) != mode){ - isIE = mode; - } - dojo.isIE = has.add("ie", isIE, true, true); - } - } - - if(thisObject && typeof callback == "string"){ - callback = thisObject[callback]; - } - - return callback.apply(thisObject, cbArguments || []); - }finally{ - dojo.doc = ret.doc = oldDoc; - dojo.isQuirks = has.add("quirks", oldQ, true, true); - dojo.isIE = has.add("ie", oldIE, true, true); - } -}; - -var ret = { - global: dojo.global, - doc: dojo.doc, - body: dojo.body, - setContext: dojo.setContext, - withGlobal: dojo.withGlobal, - withDoc: dojo.withDoc -}; - -return ret; - -}); diff --git a/lib/dojo/_base/xhr.js.uncompressed.js b/lib/dojo/_base/xhr.js.uncompressed.js deleted file mode 100644 index 94f5c78b1..000000000 --- a/lib/dojo/_base/xhr.js.uncompressed.js +++ /dev/null @@ -1,830 +0,0 @@ -define("dojo/_base/xhr", [ - "./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on" -], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){ - // module: - // dojo/_base.xhr - // summary: - // This modules defines the dojo.xhr* API. - - has.add("native-xhr", function() { - // if true, the environment has a native XHR implementation - return typeof XMLHttpRequest !== 'undefined'; - }); - - if(1 && require.getXhr){ - dojo._xhrObj = require.getXhr; - }else if (has("native-xhr")){ - dojo._xhrObj = function(){ - // summary: - // does the work of portably generating a new XMLHTTPRequest object. - try{ - return new XMLHttpRequest(); - }catch(e){ - throw new Error("XMLHTTP not available: "+e); - } - }; - }else{ - // PROGIDs are in order of decreasing likelihood; this will change in time. - for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){ - try{ - progid = XMLHTTP_PROGIDS[i++]; - if (new ActiveXObject(progid)) { - // this progid works; therefore, use it from now on - break; - } - }catch(e){ - // squelch; we're just trying to find a good ActiveX PROGID - // if they all fail, then progid ends up as the last attempt and that will signal the error - // the first time the client actually tries to exec an xhr - } - } - dojo._xhrObj= function() { - return new ActiveXObject(progid); - }; - } - - var cfg = dojo.config; - - // mix in io-query and dom-form - dojo.objectToQuery = ioq.objectToQuery; - dojo.queryToObject = ioq.queryToObject; - dojo.fieldToObject = domForm.fieldToObject; - dojo.formToObject = domForm.toObject; - dojo.formToQuery = domForm.toQuery; - dojo.formToJson = domForm.toJson; - - // need to block async callbacks from snatching this thread as the result - // of an async callback might call another sync XHR, this hangs khtml forever - // must checked by watchInFlight() - - dojo._blockAsync = false; - - // MOW: remove dojo._contentHandlers alias in 2.0 - var handlers = dojo._contentHandlers = dojo.contentHandlers = { - // summary: - // A map of availble XHR transport handle types. Name matches the - // `handleAs` attribute passed to XHR calls. - // - // description: - // A map of availble XHR transport handle types. Name matches the - // `handleAs` attribute passed to XHR calls. Each contentHandler is - // called, passing the xhr object for manipulation. The return value - // from the contentHandler will be passed to the `load` or `handle` - // functions defined in the original xhr call. - // - // example: - // Creating a custom content-handler: - // | dojo.contentHandlers.makeCaps = function(xhr){ - // | return xhr.responseText.toUpperCase(); - // | } - // | // and later: - // | dojo.xhrGet({ - // | url:"foo.txt", - // | handleAs:"makeCaps", - // | load: function(data){ /* data is a toUpper version of foo.txt */ } - // | }); - - "text": function(xhr){ - // summary: A contentHandler which simply returns the plaintext response data - return xhr.responseText; - }, - "json": function(xhr){ - // summary: A contentHandler which returns a JavaScript object created from the response data - return json.fromJson(xhr.responseText || null); - }, - "json-comment-filtered": function(xhr){ - // summary: A contentHandler which expects comment-filtered JSON. - // description: - // A contentHandler which expects comment-filtered JSON. - // the json-comment-filtered option was implemented to prevent - // "JavaScript Hijacking", but it is less secure than standard JSON. Use - // standard JSON instead. JSON prefixing can be used to subvert hijacking. - // - // Will throw a notice suggesting to use application/json mimetype, as - // json-commenting can introduce security issues. To decrease the chances of hijacking, - // use the standard `json` contentHandler, and prefix your "JSON" with: {}&& - // - // use djConfig.useCommentedJson = true to turn off the notice - if(!dojo.config.useCommentedJson){ - console.warn("Consider using the standard mimetype:application/json." - + " json-commenting can introduce security issues. To" - + " decrease the chances of hijacking, use the standard the 'json' handler and" - + " prefix your json with: {}&&\n" - + "Use djConfig.useCommentedJson=true to turn off this message."); - } - - var value = xhr.responseText; - var cStartIdx = value.indexOf("\/*"); - var cEndIdx = value.lastIndexOf("*\/"); - if(cStartIdx == -1 || cEndIdx == -1){ - throw new Error("JSON was not comment filtered"); - } - return json.fromJson(value.substring(cStartIdx+2, cEndIdx)); - }, - "javascript": function(xhr){ - // summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript - - // FIXME: try Moz and IE specific eval variants? - return dojo.eval(xhr.responseText); - }, - "xml": function(xhr){ - // summary: A contentHandler returning an XML Document parsed from the response data - var result = xhr.responseXML; - - if(has("ie")){ - if((!result || !result.documentElement)){ - //WARNING: this branch used by the xml handling in dojo.io.iframe, - //so be sure to test dojo.io.iframe if making changes below. - var ms = function(n){ return "MSXML" + n + ".DOMDocument"; }; - var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)]; - array.some(dp, function(p){ - try{ - var dom = new ActiveXObject(p); - dom.async = false; - dom.loadXML(xhr.responseText); - result = dom; - }catch(e){ return false; } - return true; - }); - } - } - return result; // DOMDocument - }, - "json-comment-optional": function(xhr){ - // summary: A contentHandler which checks the presence of comment-filtered JSON and - // alternates between the `json` and `json-comment-filtered` contentHandlers. - if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){ - return handlers["json-comment-filtered"](xhr); - }else{ - return handlers["json"](xhr); - } - } - }; - - /*===== - dojo.__IoArgs = function(){ - // url: String - // URL to server endpoint. - // content: Object? - // Contains properties with string values. These - // properties will be serialized as name1=value2 and - // passed in the request. - // timeout: Integer? - // Milliseconds to wait for the response. If this time - // passes, the then error callbacks are called. - // form: DOMNode? - // DOM node for a form. Used to extract the form values - // and send to the server. - // preventCache: Boolean? - // Default is false. If true, then a - // "dojo.preventCache" parameter is sent in the request - // with a value that changes with each request - // (timestamp). Useful only with GET-type requests. - // handleAs: String? - // Acceptable values depend on the type of IO - // transport (see specific IO calls for more information). - // rawBody: String? - // Sets the raw body for an HTTP request. If this is used, then the content - // property is ignored. This is mostly useful for HTTP methods that have - // a body to their requests, like PUT or POST. This property can be used instead - // of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively. - // ioPublish: Boolean? - // Set this explicitly to false to prevent publishing of topics related to - // IO operations. Otherwise, if djConfig.ioPublish is set to true, topics - // will be published via dojo.publish for different phases of an IO operation. - // See dojo.__IoPublish for a list of topics that are published. - // load: Function? - // This function will be - // called on a successful HTTP response code. - // error: Function? - // This function will - // be called when the request fails due to a network or server error, the url - // is invalid, etc. It will also be called if the load or handle callback throws an - // exception, unless djConfig.debugAtAllCosts is true. This allows deployed applications - // to continue to run even when a logic error happens in the callback, while making - // it easier to troubleshoot while in debug mode. - // handle: Function? - // This function will - // be called at the end of every request, whether or not an error occurs. - this.url = url; - this.content = content; - this.timeout = timeout; - this.form = form; - this.preventCache = preventCache; - this.handleAs = handleAs; - this.ioPublish = ioPublish; - this.load = function(response, ioArgs){ - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - // response: Object - // The response in the format as defined with handleAs. - } - this.error = function(response, ioArgs){ - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - // response: Object - // The response in the format as defined with handleAs. - } - this.handle = function(loadOrError, response, ioArgs){ - // loadOrError: String - // Provides a string that tells you whether this function - // was called because of success (load) or failure (error). - // response: Object - // The response in the format as defined with handleAs. - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - } - } - =====*/ - - /*===== - dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){ - // args: Object - // the original object argument to the IO call. - // xhr: XMLHttpRequest - // For XMLHttpRequest calls only, the - // XMLHttpRequest object that was used for the - // request. - // url: String - // The final URL used for the call. Many times it - // will be different than the original args.url - // value. - // query: String - // For non-GET requests, the - // name1=value1&name2=value2 parameters sent up in - // the request. - // handleAs: String - // The final indicator on how the response will be - // handled. - // id: String - // For dojo.io.script calls only, the internal - // script ID used for the request. - // canDelete: Boolean - // For dojo.io.script calls only, indicates - // whether the script tag that represents the - // request can be deleted after callbacks have - // been called. Used internally to know when - // cleanup can happen on JSONP-type requests. - // json: Object - // For dojo.io.script calls only: holds the JSON - // response for JSONP-type requests. Used - // internally to hold on to the JSON responses. - // You should not need to access it directly -- - // the same object should be passed to the success - // callbacks directly. - this.args = args; - this.xhr = xhr; - this.url = url; - this.query = query; - this.handleAs = handleAs; - this.id = id; - this.canDelete = canDelete; - this.json = json; - } - =====*/ - - - /*===== - dojo.__IoPublish = function(){ - // summary: - // This is a list of IO topics that can be published - // if djConfig.ioPublish is set to true. IO topics can be - // published for any Input/Output, network operation. So, - // dojo.xhr, dojo.io.script and dojo.io.iframe can all - // trigger these topics to be published. - // start: String - // "/dojo/io/start" is sent when there are no outstanding IO - // requests, and a new IO request is started. No arguments - // are passed with this topic. - // send: String - // "/dojo/io/send" is sent whenever a new IO request is started. - // It passes the dojo.Deferred for the request with the topic. - // load: String - // "/dojo/io/load" is sent whenever an IO request has loaded - // successfully. It passes the response and the dojo.Deferred - // for the request with the topic. - // error: String - // "/dojo/io/error" is sent whenever an IO request has errored. - // It passes the error and the dojo.Deferred - // for the request with the topic. - // done: String - // "/dojo/io/done" is sent whenever an IO request has completed, - // either by loading or by erroring. It passes the error and - // the dojo.Deferred for the request with the topic. - // stop: String - // "/dojo/io/stop" is sent when all outstanding IO requests have - // finished. No arguments are passed with this topic. - this.start = "/dojo/io/start"; - this.send = "/dojo/io/send"; - this.load = "/dojo/io/load"; - this.error = "/dojo/io/error"; - this.done = "/dojo/io/done"; - this.stop = "/dojo/io/stop"; - } - =====*/ - - - dojo._ioSetArgs = function(/*dojo.__IoArgs*/args, - /*Function*/canceller, - /*Function*/okHandler, - /*Function*/errHandler){ - // summary: - // sets up the Deferred and ioArgs property on the Deferred so it - // can be used in an io call. - // args: - // The args object passed into the public io call. Recognized properties on - // the args object are: - // canceller: - // The canceller function used for the Deferred object. The function - // will receive one argument, the Deferred object that is related to the - // canceller. - // okHandler: - // The first OK callback to be registered with Deferred. It has the opportunity - // to transform the OK response. It will receive one argument -- the Deferred - // object returned from this function. - // errHandler: - // The first error callback to be registered with Deferred. It has the opportunity - // to do cleanup on an error. It will receive two arguments: error (the - // Error object) and dfd, the Deferred object returned from this function. - - var ioArgs = {args: args, url: args.url}; - - //Get values from form if requestd. - var formObject = null; - if(args.form){ - var form = dom.byId(args.form); - //IE requires going through getAttributeNode instead of just getAttribute in some form cases, - //so use it for all. See #2844 - var actnNode = form.getAttributeNode("action"); - ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null); - formObject = domForm.toObject(form); - } - - // set up the query params - var miArgs = [{}]; - - if(formObject){ - // potentially over-ride url-provided params w/ form values - miArgs.push(formObject); - } - if(args.content){ - // stuff in content over-rides what's set by form - miArgs.push(args.content); - } - if(args.preventCache){ - miArgs.push({"dojo.preventCache": new Date().valueOf()}); - } - ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs)); - - // .. and the real work of getting the deferred in order, etc. - ioArgs.handleAs = args.handleAs || "text"; - var d = new deferred(canceller); - d.addCallbacks(okHandler, function(error){ - return errHandler(error, d); - }); - - //Support specifying load, error and handle callback functions from the args. - //For those callbacks, the "this" object will be the args object. - //The callbacks will get the deferred result value as the - //first argument and the ioArgs object as the second argument. - var ld = args.load; - if(ld && lang.isFunction(ld)){ - d.addCallback(function(value){ - return ld.call(args, value, ioArgs); - }); - } - var err = args.error; - if(err && lang.isFunction(err)){ - d.addErrback(function(value){ - return err.call(args, value, ioArgs); - }); - } - var handle = args.handle; - if(handle && lang.isFunction(handle)){ - d.addBoth(function(value){ - return handle.call(args, value, ioArgs); - }); - } - - //Plug in topic publishing, if dojo.publish is loaded. - if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){ - d.addCallbacks( - function(res){ - dojo.publish("/dojo/io/load", [d, res]); - return res; - }, - function(res){ - dojo.publish("/dojo/io/error", [d, res]); - return res; - } - ); - d.addBoth(function(res){ - dojo.publish("/dojo/io/done", [d, res]); - return res; - }); - } - - d.ioArgs = ioArgs; - - // FIXME: need to wire up the xhr object's abort method to something - // analagous in the Deferred - return d; - }; - - var _deferredCancel = function(/*Deferred*/dfd){ - // summary: canceller function for dojo._ioSetArgs call. - - dfd.canceled = true; - var xhr = dfd.ioArgs.xhr; - var _at = typeof xhr.abort; - if(_at == "function" || _at == "object" || _at == "unknown"){ - xhr.abort(); - } - var err = dfd.ioArgs.error; - if(!err){ - err = new Error("xhr cancelled"); - err.dojoType="cancel"; - } - return err; - }; - var _deferredOk = function(/*Deferred*/dfd){ - // summary: okHandler function for dojo._ioSetArgs call. - - var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr); - return ret === undefined ? null : ret; - }; - var _deferError = function(/*Error*/error, /*Deferred*/dfd){ - // summary: errHandler function for dojo._ioSetArgs call. - - if(!dfd.ioArgs.args.failOk){ - console.error(error); - } - return error; - }; - - // avoid setting a timer per request. It degrades performance on IE - // something fierece if we don't use unified loops. - var _inFlightIntvl = null; - var _inFlight = []; - - - //Use a separate count for knowing if we are starting/stopping io calls. - //Cannot use _inFlight.length since it can change at a different time than - //when we want to do this kind of test. We only want to decrement the count - //after a callback/errback has finished, since the callback/errback should be - //considered as part of finishing a request. - var _pubCount = 0; - var _checkPubCount = function(dfd){ - if(_pubCount <= 0){ - _pubCount = 0; - if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){ - dojo.publish("/dojo/io/stop"); - } - } - }; - - var _watchInFlight = function(){ - //summary: - // internal method that checks each inflight XMLHttpRequest to see - // if it has completed or if the timeout situation applies. - - var now = (new Date()).getTime(); - // make sure sync calls stay thread safe, if this callback is called - // during a sync call and this results in another sync call before the - // first sync call ends the browser hangs - if(!dojo._blockAsync){ - // we need manual loop because we often modify _inFlight (and therefore 'i') while iterating - // note: the second clause is an assigment on purpose, lint may complain - for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){ - var dfd = tif.dfd; - var func = function(){ - if(!dfd || dfd.canceled || !tif.validCheck(dfd)){ - _inFlight.splice(i--, 1); - _pubCount -= 1; - }else if(tif.ioCheck(dfd)){ - _inFlight.splice(i--, 1); - tif.resHandle(dfd); - _pubCount -= 1; - }else if(dfd.startTime){ - //did we timeout? - if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){ - _inFlight.splice(i--, 1); - var err = new Error("timeout exceeded"); - err.dojoType = "timeout"; - dfd.errback(err); - //Cancel the request so the io module can do appropriate cleanup. - dfd.cancel(); - _pubCount -= 1; - } - } - }; - if(dojo.config.debugAtAllCosts){ - func.call(this); - }else{ - try{ - func.call(this); - }catch(e){ - dfd.errback(e); - } - } - } - } - - _checkPubCount(dfd); - - if(!_inFlight.length){ - clearInterval(_inFlightIntvl); - _inFlightIntvl = null; - } - }; - - dojo._ioCancelAll = function(){ - //summary: Cancels all pending IO requests, regardless of IO type - //(xhr, script, iframe). - try{ - array.forEach(_inFlight, function(i){ - try{ - i.dfd.cancel(); - }catch(e){/*squelch*/} - }); - }catch(e){/*squelch*/} - }; - - //Automatically call cancel all io calls on unload - //in IE for trac issue #2357. - if(has("ie")){ - on(window, "unload", dojo._ioCancelAll); - } - - dojo._ioNotifyStart = function(/*Deferred*/dfd){ - // summary: - // If dojo.publish is available, publish topics - // about the start of a request queue and/or the - // the beginning of request. - // description: - // Used by IO transports. An IO transport should - // call this method before making the network connection. - if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){ - if(!_pubCount){ - dojo.publish("/dojo/io/start"); - } - _pubCount += 1; - dojo.publish("/dojo/io/send", [dfd]); - } - }; - - dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){ - // summary: - // Watches the io request represented by dfd to see if it completes. - // dfd: Deferred - // The Deferred object to watch. - // validCheck: Function - // Function used to check if the IO request is still valid. Gets the dfd - // object as its only argument. - // ioCheck: Function - // Function used to check if basic IO call worked. Gets the dfd - // object as its only argument. - // resHandle: Function - // Function used to process response. Gets the dfd - // object as its only argument. - var args = dfd.ioArgs.args; - if(args.timeout){ - dfd.startTime = (new Date()).getTime(); - } - - _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle}); - if(!_inFlightIntvl){ - _inFlightIntvl = setInterval(_watchInFlight, 50); - } - // handle sync requests - //A weakness: async calls in flight - //could have their handlers called as part of the - //_watchInFlight call, before the sync's callbacks - // are called. - if(args.sync){ - _watchInFlight(); - } - }; - - var _defaultContentType = "application/x-www-form-urlencoded"; - - var _validCheck = function(/*Deferred*/dfd){ - return dfd.ioArgs.xhr.readyState; //boolean - }; - var _ioCheck = function(/*Deferred*/dfd){ - return 4 == dfd.ioArgs.xhr.readyState; //boolean - }; - var _resHandle = function(/*Deferred*/dfd){ - var xhr = dfd.ioArgs.xhr; - if(dojo._isDocumentOk(xhr)){ - dfd.callback(dfd); - }else{ - var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status); - err.status = xhr.status; - err.responseText = xhr.responseText; - err.xhr = xhr; - dfd.errback(err); - } - }; - - dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){ - //summary: Adds query params discovered by the io deferred construction to the URL. - //Only use this for operations which are fundamentally GET-type operations. - if(ioArgs.query.length){ - ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query; - ioArgs.query = null; - } - }; - - /*===== - dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, { - constructor: function(){ - // summary: - // In addition to the properties listed for the dojo._IoArgs type, - // the following properties are allowed for dojo.xhr* methods. - // handleAs: String? - // Acceptable values are: text (default), json, json-comment-optional, - // json-comment-filtered, javascript, xml. See `dojo.contentHandlers` - // sync: Boolean? - // false is default. Indicates whether the request should - // be a synchronous (blocking) request. - // headers: Object? - // Additional HTTP headers to send in the request. - // failOk: Boolean? - // false is default. Indicates whether a request should be - // allowed to fail (and therefore no console error message in - // the event of a failure) - // contentType: String|Boolean - // "application/x-www-form-urlencoded" is default. Set to false to - // prevent a Content-Type header from being sent, or to a string - // to send a different Content-Type. - this.handleAs = handleAs; - this.sync = sync; - this.headers = headers; - this.failOk = failOk; - } - }); - =====*/ - - dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){ - // summary: - // Sends an HTTP request with the given method. - // description: - // Sends an HTTP request with the given method. - // See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts - // for those HTTP methods. There are also methods for "raw" PUT and POST methods - // via dojo.rawXhrPut() and dojo.rawXhrPost() respectively. - // method: - // HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase. - // hasBody: - // If the request has an HTTP body, then pass true for hasBody. - - //Make the Deferred object for this xhr request. - var dfd = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError); - var ioArgs = dfd.ioArgs; - - //Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like - //the one used for iframe proxies. - var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args); - //If XHR factory fails, cancel the deferred. - if(!xhr){ - dfd.cancel(); - return dfd; - } - - //Allow for specifying the HTTP body completely. - if("postData" in args){ - ioArgs.query = args.postData; - }else if("putData" in args){ - ioArgs.query = args.putData; - }else if("rawBody" in args){ - ioArgs.query = args.rawBody; - }else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){ - //Check for hasBody being passed. If no hasBody, - //then only append query string if not a POST or PUT request. - dojo._ioAddQueryToUrl(ioArgs); - } - - // IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open). - // workaround for IE6's apply() "issues" - xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined); - if(args.headers){ - for(var hdr in args.headers){ - if(hdr.toLowerCase() === "content-type" && !args.contentType){ - args.contentType = args.headers[hdr]; - }else if(args.headers[hdr]){ - //Only add header if it has a value. This allows for instnace, skipping - //insertion of X-Requested-With by specifying empty value. - xhr.setRequestHeader(hdr, args.headers[hdr]); - } - } - } - // FIXME: is this appropriate for all content types? - if(args.contentType !== false){ - xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType); - } - if(!args.headers || !("X-Requested-With" in args.headers)){ - xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest"); - } - // FIXME: set other headers here! - dojo._ioNotifyStart(dfd); - if(dojo.config.debugAtAllCosts){ - xhr.send(ioArgs.query); - }else{ - try{ - xhr.send(ioArgs.query); - }catch(e){ - ioArgs.error = e; - dfd.cancel(); - } - } - dojo._ioWatch(dfd, _validCheck, _ioCheck, _resHandle); - xhr = null; - return dfd; // dojo.Deferred - }; - - dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){ - // summary: - // Sends an HTTP GET request to the server. - return dojo.xhr("GET", args); // dojo.Deferred - }; - - dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){ - // summary: - // Sends an HTTP POST request to the server. In addtion to the properties - // listed for the dojo.__XhrArgs type, the following property is allowed: - // postData: - // String. Send raw data in the body of the POST request. - return dojo.xhr("POST", args, true); // dojo.Deferred - }; - - dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){ - // summary: - // Sends an HTTP PUT request to the server. In addtion to the properties - // listed for the dojo.__XhrArgs type, the following property is allowed: - // putData: - // String. Send raw data in the body of the PUT request. - return dojo.xhr("PUT", args, true); // dojo.Deferred - }; - - dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){ - // summary: - // Sends an HTTP DELETE request to the server. - return dojo.xhr("DELETE", args); //dojo.Deferred - }; - - /* - dojo.wrapForm = function(formNode){ - //summary: - // A replacement for FormBind, but not implemented yet. - - // FIXME: need to think harder about what extensions to this we might - // want. What should we allow folks to do w/ this? What events to - // set/send? - throw new Error("dojo.wrapForm not yet implemented"); - } - */ - - dojo._isDocumentOk = function(http){ - var stat = http.status || 0; - stat = - (stat >= 200 && stat < 300) || // allow any 2XX response code - stat == 304 || // or, get it out of the cache - stat == 1223 || // or, Internet Explorer mangled the status code - !stat; // or, we're Titanium/browser chrome/chrome extension requesting a local file - return stat; // Boolean - }; - - dojo._getText = function(url){ - var result; - dojo.xhrGet({url:url, sync:true, load:function(text){ - result = text; - }}); - return result; - }; - - // Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module - lang.mixin(dojo.xhr, { - _xhrObj: dojo._xhrObj, - fieldToObject: domForm.fieldToObject, - formToObject: domForm.toObject, - objectToQuery: ioq.objectToQuery, - formToQuery: domForm.toQuery, - formToJson: domForm.toJson, - queryToObject: ioq.queryToObject, - contentHandlers: handlers, - _ioSetArgs: dojo._ioSetArgs, - _ioCancelAll: dojo._ioCancelAll, - _ioNotifyStart: dojo._ioNotifyStart, - _ioWatch: dojo._ioWatch, - _ioAddQueryToUrl: dojo._ioAddQueryToUrl, - _isDocumentOk: dojo._isDocumentOk, - _getText: dojo._getText, - get: dojo.xhrGet, - post: dojo.xhrPost, - put: dojo.xhrPut, - del: dojo.xhrDelete // because "delete" is a reserved word - }); - - return dojo.xhr; -}); |