@ms-atlas/datastudio 0.1.19

package/ExternalLibraries/signals.min.js

@@ -0,0 +1,179 @@
+/*
+
+ JS Signals <http://millermedeiros.github.com/js-signals/>
+ Released under the MIT license
+ Author: Miller Medeiros
+ Version: 1.0.0 - Build: 268 (2012/11/29 05:48 PM)
+*/
+(function (i) {
+  function h(a, b, c, d, e) {
+    this._listener = b;
+    this._isOnce = c;
+    this.context = d;
+    this._signal = a;
+    this._priority = e || 0;
+  }
+  function g(a, b) {
+    if (typeof a !== "function")
+      throw Error(
+        "listener is a required param of {fn}() and should be a Function.".replace(
+          "{fn}",
+          b
+        )
+      );
+  }
+  function e() {
+    this._bindings = [];
+    this._prevParams = null;
+    var a = this;
+    this.dispatch = function () {
+      e.prototype.dispatch.apply(a, arguments);
+    };
+  }
+  h.prototype = {
+    active: !0,
+    params: null,
+    execute: function (a) {
+      var b;
+      this.active &&
+        this._listener &&
+        ((a = this.params ? this.params.concat(a) : a),
+        (b = this._listener.apply(this.context, a)),
+        this._isOnce && this.detach());
+      return b;
+    },
+    detach: function () {
+      return this.isBound()
+        ? this._signal.remove(this._listener, this.context)
+        : null;
+    },
+    isBound: function () {
+      return !!this._signal && !!this._listener;
+    },
+    isOnce: function () {
+      return this._isOnce;
+    },
+    getListener: function () {
+      return this._listener;
+    },
+    getSignal: function () {
+      return this._signal;
+    },
+    _destroy: function () {
+      delete this._signal;
+      delete this._listener;
+      delete this.context;
+    },
+    toString: function () {
+      return (
+        "[SignalBinding isOnce:" +
+        this._isOnce +
+        ", isBound:" +
+        this.isBound() +
+        ", active:" +
+        this.active +
+        "]"
+      );
+    },
+  };
+  e.prototype = {
+    VERSION: "1.0.0",
+    memorize: !1,
+    _shouldPropagate: !0,
+    active: !0,
+    _registerListener: function (a, b, c, d) {
+      var e = this._indexOfListener(a, c);
+      if (e !== -1) {
+        if (((a = this._bindings[e]), a.isOnce() !== b))
+          throw Error(
+            "You cannot add" +
+              (b ? "" : "Once") +
+              "() then add" +
+              (!b ? "" : "Once") +
+              "() the same listener without removing the relationship first."
+          );
+      } else (a = new h(this, a, b, c, d)), this._addBinding(a);
+      this.memorize && this._prevParams && a.execute(this._prevParams);
+      return a;
+    },
+    _addBinding: function (a) {
+      var b = this._bindings.length;
+      do --b;
+      while (this._bindings[b] && a._priority <= this._bindings[b]._priority);
+      this._bindings.splice(b + 1, 0, a);
+    },
+    _indexOfListener: function (a, b) {
+      for (var c = this._bindings.length, d; c--; )
+        if (((d = this._bindings[c]), d._listener === a && d.context === b))
+          return c;
+      return -1;
+    },
+    has: function (a, b) {
+      return this._indexOfListener(a, b) !== -1;
+    },
+    add: function (a, b, c) {
+      g(a, "add");
+      return this._registerListener(a, !1, b, c);
+    },
+    addOnce: function (a, b, c) {
+      g(a, "addOnce");
+      return this._registerListener(a, !0, b, c);
+    },
+    remove: function (a, b) {
+      g(a, "remove");
+      var c = this._indexOfListener(a, b);
+      c !== -1 && (this._bindings[c]._destroy(), this._bindings.splice(c, 1));
+      return a;
+    },
+    removeAll: function () {
+      for (var a = this._bindings.length; a--; ) this._bindings[a]._destroy();
+      this._bindings.length = 0;
+    },
+    getNumListeners: function () {
+      return this._bindings.length;
+    },
+    halt: function () {
+      this._shouldPropagate = !1;
+    },
+    dispatch: function (a) {
+      if (this.active) {
+        var b = Array.prototype.slice.call(arguments),
+          c = this._bindings.length,
+          d;
+        if (this.memorize) this._prevParams = b;
+        if (c) {
+          d = this._bindings.slice();
+          this._shouldPropagate = !0;
+          do c--;
+          while (d[c] && this._shouldPropagate && d[c].execute(b) !== !1);
+        }
+      }
+    },
+    forget: function () {
+      this._prevParams = null;
+    },
+    dispose: function () {
+      this.removeAll();
+      delete this._bindings;
+      delete this._prevParams;
+    },
+    toString: function () {
+      return (
+        "[Signal active:" +
+        this.active +
+        " numListeners:" +
+        this.getNumListeners() +
+        "]"
+      );
+    },
+  };
+  var f = e;
+  f.Signal = e;
+  typeof define === "function" && define.amd
+    ? define([], function () {
+        return f;
+      })
+    : typeof module !== "undefined" && module.exports
+    ? (module.exports = f)
+    : (i.signals = f);
+})(this);

package/ExternalLibraries/text.js

@@ -0,0 +1,445 @@
+/**
+ * @license RequireJS text 2.0.12 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/text for details
+ */
+/*jslint regexp: true */
+/*global require, XMLHttpRequest, ActiveXObject,
+  define, window, process, Packages,
+  java, location, Components, FileUtils */
+
+define(["module"], function (module) {
+  "use strict";
+
+  var text,
+    fs,
+    Cc,
+    Ci,
+    xpcIsWindows,
+    progIds = ["Msxml2.XMLHTTP", "Microsoft.XMLHTTP", "Msxml2.XMLHTTP.4.0"],
+    xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
+    bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
+    hasLocation = typeof location !== "undefined" && location.href,
+    defaultProtocol =
+      hasLocation && location.protocol && location.protocol.replace(/\:/, ""),
+    defaultHostName = hasLocation && location.hostname,
+    defaultPort = hasLocation && (location.port || undefined),
+    buildMap = {},
+    masterConfig = (module.config && module.config()) || {};
+
+  text = {
+    version: "2.0.12",
+
+    strip: function (content) {
+      //Strips <?xml ...?> declarations so that external SVG and XML
+      //documents can be added to a document without worry. Also, if the string
+      //is an HTML document, only the part inside the body tag is returned.
+      if (content) {
+        content = content.replace(xmlRegExp, "");
+        var matches = content.match(bodyRegExp);
+        if (matches) {
+          content = matches[1];
+        }
+      } else {
+        content = "";
+      }
+      return content;
+    },
+
+    jsEscape: function (content) {
+      return content
+        .replace(/(['\\])/g, "\\$1")
+        .replace(/[\f]/g, "\\f")
+        .replace(/[\b]/g, "\\b")
+        .replace(/[\n]/g, "\\n")
+        .replace(/[\t]/g, "\\t")
+        .replace(/[\r]/g, "\\r")
+        .replace(/[\u2028]/g, "\\u2028")
+        .replace(/[\u2029]/g, "\\u2029");
+    },
+
+    createXhr:
+      masterConfig.createXhr ||
+      function () {
+        //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
+        var xhr, i, progId;
+        if (typeof XMLHttpRequest !== "undefined") {
+          return new XMLHttpRequest();
+        } else if (typeof ActiveXObject !== "undefined") {
+          for (i = 0; i < 3; i += 1) {
+            progId = progIds[i];
+            try {
+              xhr = new ActiveXObject(progId);
+            } catch (e) {}
+
+            if (xhr) {
+              progIds = [progId]; // so faster next time
+              break;
+            }
+          }
+        }
+
+        return xhr;
+      },
+
+    /**
+     * Parses a resource name into its component parts. Resource names
+     * look like: module/name.ext!strip, where the !strip part is
+     * optional.
+     * @param {String} name the resource name
+     * @returns {Object} with properties "moduleName", "ext" and "strip"
+     * where strip is a boolean.
+     */
+    parseName: function (name) {
+      var modName,
+        ext,
+        temp,
+        strip = false,
+        index = name.indexOf("."),
+        isRelative = name.indexOf("./") === 0 || name.indexOf("../") === 0;
+
+      if (index !== -1 && (!isRelative || index > 1)) {
+        modName = name.substring(0, index);
+        ext = name.substring(index + 1, name.length);
+      } else {
+        modName = name;
+      }
+
+      temp = ext || modName;
+      index = temp.indexOf("!");
+      if (index !== -1) {
+        //Pull off the strip arg.
+        strip = temp.substring(index + 1) === "strip";
+        temp = temp.substring(0, index);
+        if (ext) {
+          ext = temp;
+        } else {
+          modName = temp;
+        }
+      }
+
+      return {
+        moduleName: modName,
+        ext: ext,
+        strip: strip,
+      };
+    },
+
+    xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
+
+    /**
+     * Is an URL on another domain. Only works for browser use, returns
+     * false in non-browser environments. Only used to know if an
+     * optimized .js version of a text resource should be loaded
+     * instead.
+     * @param {String} url
+     * @returns Boolean
+     */
+    useXhr: function (url, protocol, hostname, port) {
+      var uProtocol,
+        uHostName,
+        uPort,
+        match = text.xdRegExp.exec(url);
+      if (!match) {
+        return true;
+      }
+      uProtocol = match[2];
+      uHostName = match[3];
+
+      uHostName = uHostName.split(":");
+      uPort = uHostName[1];
+      uHostName = uHostName[0];
+
+      return (
+        (!uProtocol || uProtocol === protocol) &&
+        (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
+        ((!uPort && !uHostName) || uPort === port)
+      );
+    },
+
+    finishLoad: function (name, strip, content, onLoad) {
+      content = strip ? text.strip(content) : content;
+      if (masterConfig.isBuild) {
+        buildMap[name] = content;
+      }
+      onLoad(content);
+    },
+
+    load: function (name, req, onLoad, config) {
+      //Name has format: some.module.filext!strip
+      //The strip part is optional.
+      //if strip is present, then that means only get the string contents
+      //inside a body tag in an HTML string. For XML/SVG content it means
+      //removing the <?xml ...?> declarations so the content can be inserted
+      //into the current doc without problems.
+
+      // Do not bother with the work if a build and text will
+      // not be inlined.
+      if (config && config.isBuild && !config.inlineText) {
+        onLoad();
+        return;
+      }
+
+      masterConfig.isBuild = config && config.isBuild;
+
+      var parsed = text.parseName(name),
+        nonStripName = parsed.moduleName + (parsed.ext ? "." + parsed.ext : ""),
+        url = req.toUrl(nonStripName),
+        useXhr = masterConfig.useXhr || text.useXhr;
+
+      // Do not load if it is an empty: url
+      if (url.indexOf("empty:") === 0) {
+        onLoad();
+        return;
+      }
+
+      //Load the text. Use XHR if possible and in a browser.
+      if (
+        !hasLocation ||
+        useXhr(url, defaultProtocol, defaultHostName, defaultPort)
+      ) {
+        text.get(
+          url,
+          function (content) {
+            text.finishLoad(name, parsed.strip, content, onLoad);
+          },
+          function (err) {
+            if (onLoad.error) {
+              onLoad.error(err);
+            }
+          }
+        );
+      } else {
+        //Need to fetch the resource across domains. Assume
+        //the resource has been optimized into a JS module. Fetch
+        //by the module name + extension, but do not include the
+        //!strip part to avoid file system issues.
+        req([nonStripName], function (content) {
+          text.finishLoad(
+            parsed.moduleName + "." + parsed.ext,
+            parsed.strip,
+            content,
+            onLoad
+          );
+        });
+      }
+    },
+
+    write: function (pluginName, moduleName, write, config) {
+      if (buildMap.hasOwnProperty(moduleName)) {
+        var content = text.jsEscape(buildMap[moduleName]);
+        write.asModule(
+          pluginName + "!" + moduleName,
+          "define(function () { return '" + content + "';});\n"
+        );
+      }
+    },
+
+    writeFile: function (pluginName, moduleName, req, write, config) {
+      var parsed = text.parseName(moduleName),
+        extPart = parsed.ext ? "." + parsed.ext : "",
+        nonStripName = parsed.moduleName + extPart,
+        //Use a '.js' file name so that it indicates it is a
+        //script that can be loaded across domains.
+        fileName = req.toUrl(parsed.moduleName + extPart) + ".js";
+
+      //Leverage own load() method to load plugin value, but only
+      //write out values that do not have the strip argument,
+      //to avoid any potential issues with ! in file names.
+      text.load(
+        nonStripName,
+        req,
+        function (value) {
+          //Use own write() method to construct full module value.
+          //But need to create shell that translates writeFile's
+          //write() to the right interface.
+          var textWrite = function (contents) {
+            return write(fileName, contents);
+          };
+          textWrite.asModule = function (moduleName, contents) {
+            return write.asModule(moduleName, fileName, contents);
+          };
+
+          text.write(pluginName, nonStripName, textWrite, config);
+        },
+        config
+      );
+    },
+  };
+
+  if (
+    masterConfig.env === "node" ||
+    (!masterConfig.env &&
+      typeof process !== "undefined" &&
+      process.versions &&
+      !!process.versions.node &&
+      !process.versions["node-webkit"])
+  ) {
+    //Using special require.nodeRequire, something added by r.js.
+    fs = require.nodeRequire("fs");
+
+    text.get = function (url, callback, errback) {
+      try {
+        var file = fs.readFileSync(url, "utf8");
+        //Remove BOM (Byte Mark Order) from utf8 files if it is there.
+        if (file.indexOf("\uFEFF") === 0) {
+          file = file.substring(1);
+        }
+        callback(file);
+      } catch (e) {
+        if (errback) {
+          errback(e);
+        }
+      }
+    };
+  } else if (
+    masterConfig.env === "xhr" ||
+    (!masterConfig.env && text.createXhr())
+  ) {
+    text.get = function (url, callback, errback, headers) {
+      var xhr = text.createXhr(),
+        header;
+      xhr.open("GET", url, true);
+
+      //Allow plugins direct access to xhr headers
+      if (headers) {
+        for (header in headers) {
+          if (headers.hasOwnProperty(header)) {
+            xhr.setRequestHeader(header.toLowerCase(), headers[header]);
+          }
+        }
+      }
+
+      //Allow overrides specified in config
+      if (masterConfig.onXhr) {
+        masterConfig.onXhr(xhr, url);
+      }
+
+      xhr.onreadystatechange = function (evt) {
+        var status, err;
+        //Do not explicitly handle errors, those should be
+        //visible via console output in the browser.
+        if (xhr.readyState === 4) {
+          status = xhr.status || 0;
+          if (status > 399 && status < 600) {
+            //An http 4xx or 5xx error. Signal an error.
+            err = new Error(url + " HTTP status: " + status);
+            err.xhr = xhr;
+            if (errback) {
+              errback(err);
+            }
+          } else {
+            callback(xhr.responseText);
+          }
+
+          if (masterConfig.onXhrComplete) {
+            masterConfig.onXhrComplete(xhr, url);
+          }
+        }
+      };
+      xhr.send(null);
+    };
+  } else if (
+    masterConfig.env === "rhino" ||
+    (!masterConfig.env &&
+      typeof Packages !== "undefined" &&
+      typeof java !== "undefined")
+  ) {
+    //Why Java, why is this so awkward?
+    text.get = function (url, callback) {
+      var stringBuffer,
+        line,
+        encoding = "utf-8",
+        file = new java.io.File(url),
+        lineSeparator = java.lang.System.getProperty("line.separator"),
+        input = new java.io.BufferedReader(
+          new java.io.InputStreamReader(
+            new java.io.FileInputStream(file),
+            encoding
+          )
+        ),
+        content = "";
+      try {
+        stringBuffer = new java.lang.StringBuffer();
+        line = input.readLine();
+
+        // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+        // http://www.unicode.org/faq/utf_bom.html
+
+        // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+        // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+        if (line && line.length() && line.charAt(0) === 0xfeff) {
+          // Eat the BOM, since we've already found the encoding on this file,
+          // and we plan to concatenating this buffer with others; the BOM should
+          // only appear at the top of a file.
+          line = line.substring(1);
+        }
+
+        if (line !== null) {
+          stringBuffer.append(line);
+        }
+
+        while ((line = input.readLine()) !== null) {
+          stringBuffer.append(lineSeparator);
+          stringBuffer.append(line);
+        }
+        //Make sure we return a JavaScript string and not a Java string.
+        content = String(stringBuffer.toString()); //String
+      } finally {
+        input.close();
+      }
+      callback(content);
+    };
+  } else if (
+    masterConfig.env === "xpconnect" ||
+    (!masterConfig.env &&
+      typeof Components !== "undefined" &&
+      Components.classes &&
+      Components.interfaces)
+  ) {
+    //Avert your gaze!
+    Cc = Components.classes;
+    Ci = Components.interfaces;
+    Components.utils["import"]("resource://gre/modules/FileUtils.jsm");
+    xpcIsWindows = "@mozilla.org/windows-registry-key;1" in Cc;
+
+    text.get = function (url, callback) {
+      var inStream,
+        convertStream,
+        fileObj,
+        readData = {};
+
+      if (xpcIsWindows) {
+        url = url.replace(/\//g, "\\");
+      }
+
+      fileObj = new FileUtils.File(url);
+
+      //XPCOM, you so crazy
+      try {
+        inStream = Cc[
+          "@mozilla.org/network/file-input-stream;1"
+        ].createInstance(Ci.nsIFileInputStream);
+        inStream.init(fileObj, 1, 0, false);
+
+        convertStream = Cc[
+          "@mozilla.org/intl/converter-input-stream;1"
+        ].createInstance(Ci.nsIConverterInputStream);
+        convertStream.init(
+          inStream,
+          "utf-8",
+          inStream.available(),
+          Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER
+        );
+
+        convertStream.readString(inStream.available(), readData);
+        convertStream.close();
+        inStream.close();
+        callback(readData.value);
+      } catch (e) {
+        throw new Error(((fileObj && fileObj.path) || "") + ": " + e);
+      }
+    };
+  }
+  return text;
+});