--- /dev/null
+define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
+ // module:
+ // dojo/_base/kernel
+
+ // 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 = {
+ // summary:
+ // This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+
+ // 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 AMD map configuration variable which can relocate packages to different names. For backcompat,
+ // only the "*" mapping is supported. 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.map && require.map[module.id.match(/[^\/]+/)[0]]),
+
+ 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;
+
+ /*===== dojo.__docParserConfigureScopeMap(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;
+
+ var rev = "$Rev: 30226 $".match(/\d+/);
+ dojo.version = {
+ // summary:
+ // Version number of the Dojo Toolkit
+ // description:
+ // Hash about the version, including
+ //
+ // - 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
+
+ major: 1, minor: 8, 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.
+ 1 || has.add("extend-dojo", 1);
+
+
+ (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+ /*=====
+ 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`
+ };
+ =====*/
+
+
+ if( 0 ){
+ dojo.exit = function(exitcode){
+ quit(exitcode);
+ };
+ }else{
+ dojo.exit = function(){
+ };
+ }
+
+ 1 || 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
+ );
+ dojo.deprecated = dojo.experimental = function(){};
+ 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);
+ };
+ }
+
+ 1 || 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});
+ }
+ }
+
+ 1 || 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;
+});
git.wh0rd.org / tt-rss.git / blobdiff