From f0cfe83e3725f9a3928da97a6e3085e79cb25309 Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Mon, 18 Mar 2013 10:26:24 +0400 Subject: upgrade dojo to 1.8.3 (refs #570) --- lib/dojo/has.js.uncompressed.js | 173 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 lib/dojo/has.js.uncompressed.js (limited to 'lib/dojo/has.js.uncompressed.js') diff --git a/lib/dojo/has.js.uncompressed.js b/lib/dojo/has.js.uncompressed.js new file mode 100644 index 000000000..6171de8f3 --- /dev/null +++ b/lib/dojo/has.js.uncompressed.js @@ -0,0 +1,173 @@ +define("dojo/has", ["require", "module"], function(require, module){ + // module: + // dojo/has + // summary: + // Defines the has.js API and several feature tests used by dojo. + // description: + // This module defines the has API as described by the project has.js with the following additional features: + // + // - the has test cache is exposed at has.cache. + // - the method has.add includes a forth parameter that controls whether or not existing tests are replaced + // - the loader's has cache may be optionally copied into this module's has cahce. + // + // This module adopted from https://github.com/phiggins42/has.js; thanks has.js team! + + // try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one + // if using a foreign loader, then the has cache may be initialized via the config object for this module + // WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail + var has = require.has || function(){}; + if(! 1 ){ + var + isBrowser = + // the most fundamental decision: are we in the browser? + typeof window != "undefined" && + typeof location != "undefined" && + typeof document != "undefined" && + window.location == location && window.document == document, + + // has API variables + global = this, + doc = isBrowser && document, + element = doc && doc.createElement("DiV"), + cache = (module.config && module.config()) || {}; + + has = function(name){ + // summary: + // Return the current value of the named feature. + // + // name: String|Integer + // The name (if a string) or identifier (if an integer) of the feature to test. + // + // description: + // Returns the value of the feature named by name. The feature must have been + // previously added to the cache by has.add. + + return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean + }; + + has.cache = cache; + + has.add = function(name, test, now, force){ + // summary: + // Register a new feature test for some named feature. + // name: String|Integer + // The name (if a string) or identifier (if an integer) of the feature to test. + // test: Function + // A test function to register. If a function, queued for testing until actually + // needed. The test function should return a boolean indicating + // the presence of a feature or bug. + // now: Boolean? + // Optional. Omit if `test` is not a function. Provides a way to immediately + // run the test and cache the result. + // force: Boolean? + // Optional. If the test already exists and force is truthy, then the existing + // test will be replaced; otherwise, add does not replace an existing test (that + // is, by default, the first test advice wins). + // example: + // A redundant test, testFn with immediate execution: + // | has.add("javascript", function(){ return true; }, true); + // + // example: + // Again with the redundantness. You can do this in your tests, but we should + // not be doing this in any internal has.js tests + // | has.add("javascript", true); + // + // example: + // Three things are passed to the testFunction. `global`, `document`, and a generic element + // from which to work your test should the need arise. + // | has.add("bug-byid", function(g, d, el){ + // | // g == global, typically window, yadda yadda + // | // d == document object + // | // el == the generic element. a `has` element. + // | return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer + // | }); + + (typeof cache[name]=="undefined" || force) && (cache[name]= test); + return now && has(name); + }; + + // since we're operating under a loader that doesn't provide a has API, we must explicitly initialize + // has as it would have otherwise been initialized by the dojo loader; use has.add to the builder + // can optimize these away iff desired + 1 || has.add("host-browser", isBrowser); + 1 || has.add("dom", isBrowser); + 1 || has.add("dojo-dom-ready-api", 1); + 1 || has.add("dojo-sniff", 1); + } + + if( 1 ){ + // Common application level tests + has.add("dom-addeventlistener", !!document.addEventListener); + has.add("touch", "ontouchstart" in document); + // I don't know if any of these tests are really correct, just a rough guess + has.add("device-width", screen.availWidth || innerWidth); + + // Tests for DOMNode.attributes[] behavior: + // - dom-attributes-explicit - attributes[] only lists explicitly user specified attributes + // - dom-attributes-specified-flag (IE8) - need to check attr.specified flag to skip attributes user didn't specify + // - Otherwise, in IE6-7. attributes[] will list hundreds of values, so need to do outerHTML to get attrs instead. + var form = document.createElement("form"); + has.add("dom-attributes-explicit", form.attributes.length == 0); // W3C + has.add("dom-attributes-specified-flag", form.attributes.length > 0 && form.attributes.length < 40); // IE8 + } + + has.clearElement = function(element){ + // summary: + // Deletes the contents of the element passed to test functions. + element.innerHTML= ""; + return element; + }; + + has.normalize = function(id, toAbsMid){ + // summary: + // Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s). + // + // toAbsMid: Function + // Resolves a relative module id into an absolute module id + var + tokens = id.match(/[\?:]|[^:\?]*/g), i = 0, + get = function(skip){ + var term = tokens[i++]; + if(term == ":"){ + // empty string module name, resolves to 0 + return 0; + }else{ + // postfixed with a ? means it is a feature to branch on, the term is the name of the feature + if(tokens[i++] == "?"){ + if(!skip && has(term)){ + // matched the feature, get the first value from the options + return get(); + }else{ + // did not match, get the second value, passing over the first + get(true); + return get(skip); + } + } + // a module + return term || 0; + } + }; + id = get(); + return id && toAbsMid(id); + }; + + has.load = function(id, parentRequire, loaded){ + // summary: + // Conditional loading of AMD modules based on a has feature test value. + // id: String + // Gives the resolved module id to load. + // parentRequire: Function + // The loader require function with respect to the module that contained the plugin resource in it's + // dependency list. + // loaded: Function + // Callback to loader that consumes result of plugin demand. + + if(id){ + parentRequire([id], loaded); + }else{ + loaded(); + } + }; + + return has; +}); -- cgit v1.2.3