@ms-atlas/datastudio 0.1.20

package/ExternalLibraries/hull.js

@@ -0,0 +1,444 @@
+!(function (e) {
+  if ("object" == typeof exports && "undefined" != typeof module)
+    module.exports = e();
+  else if ("function" == typeof define && define.amd) define([], e);
+  else {
+    var f;
+    "undefined" != typeof window
+      ? (f = window)
+      : "undefined" != typeof global
+      ? (f = global)
+      : "undefined" != typeof self && (f = self),
+      (f.hull = e());
+  }
+})(function () {
+  var define, module, exports;
+  return (function e(t, n, r) {
+    function s(o, u) {
+      if (!n[o]) {
+        if (!t[o]) {
+          var a = typeof require == "function" && require;
+          if (!u && a) return a(o, !0);
+          if (i) return i(o, !0);
+          var f = new Error("Cannot find module '" + o + "'");
+          throw ((f.code = "MODULE_NOT_FOUND"), f);
+        }
+        var l = (n[o] = { exports: {} });
+        t[o][0].call(
+          l.exports,
+          function (e) {
+            var n = t[o][1][e];
+            return s(n ? n : e);
+          },
+          l,
+          l.exports,
+          e,
+          t,
+          n,
+          r
+        );
+      }
+      return n[o].exports;
+    }
+    var i = typeof require == "function" && require;
+    for (var o = 0; o < r.length; o++) s(r[o]);
+    return s;
+  })(
+    {
+      1: [
+        function (require, module, exports) {
+          function Grid(points) {
+            var _cells = [];
+
+            points.forEach(function (point) {
+              var cellXY = this.point2CellXY(point),
+                x = cellXY[0],
+                y = cellXY[1];
+              if (_cells[x] === undefined) {
+                _cells[x] = [];
+              }
+              if (_cells[x][y] === undefined) {
+                _cells[x][y] = [];
+              }
+              _cells[x][y].push(point);
+            }, this);
+
+            this.cellPoints = function (x, y) {
+              // (Number, Number) -> Array
+              return _cells[x] !== undefined && _cells[x][y] !== undefined
+                ? _cells[x][y]
+                : [];
+            };
+
+            this.removePoint = function (point) {
+              // (Array) -> Array
+              var cellXY = this.point2CellXY(point),
+                cell = _cells[cellXY[0]][cellXY[1]],
+                pointIdxInCell;
+
+              for (var i = 0; i < cell.length; i++) {
+                if (cell[i][0] === point[0] && cell[i][1] === point[1]) {
+                  pointIdxInCell = i;
+                  break;
+                }
+              }
+
+              cell.splice(pointIdxInCell, 1);
+
+              return cell;
+            };
+          }
+
+          Grid.prototype = {
+            point2CellXY: function (point) {
+              // (Array) -> Array
+              var x = parseInt(point[0] / Grid.CELL_SIZE),
+                y = parseInt(point[1] / Grid.CELL_SIZE);
+              return [x, y];
+            },
+
+            rangePoints: function (bbox) {
+              // (Array) -> Array
+              var tlCellXY = this.point2CellXY([bbox[0], bbox[1]]),
+                brCellXY = this.point2CellXY([bbox[2], bbox[3]]),
+                points = [];
+
+              for (var x = tlCellXY[0]; x <= brCellXY[0]; x++) {
+                for (var y = tlCellXY[1]; y <= brCellXY[1]; y++) {
+                  points = points.concat(this.cellPoints(x, y));
+                }
+              }
+
+              return points;
+            },
+
+            addBorder2Bbox: function (bbox, border) {
+              // (Array, Number) -> Array
+              return [
+                bbox[0] - border * Grid.CELL_SIZE,
+                bbox[1] - border * Grid.CELL_SIZE,
+                bbox[2] + border * Grid.CELL_SIZE,
+                bbox[3] + border * Grid.CELL_SIZE,
+              ];
+            },
+          };
+
+          function grid(points) {
+            return new Grid(points);
+          }
+
+          Grid.CELL_SIZE = 10;
+
+          module.exports = grid;
+        },
+        {},
+      ],
+      2: [
+        function (require, module, exports) {
+          /*
+ (c) 2014-2015, Andrii Heonia
+ Hull.js, a JavaScript library for concave hull generation by set of points.
+ https://github.com/AndriiHeonia/hull
+*/
+
+          var intersect = require("./intersect.js");
+          var grid = require("./grid.js");
+
+          function _formatToXy(pointset, format) {
+            if (format === undefined) {
+              return pointset;
+            }
+            return pointset.map(function (pt) {
+              /*jslint evil: true */
+              var _getXY = new Function(
+                "pt",
+                "return [pt" + format[0] + "," + "pt" + format[1] + "];"
+              );
+              return _getXY(pt);
+            });
+          }
+
+          function _xyToFormat(pointset, format) {
+            if (format === undefined) {
+              return pointset;
+            }
+            return pointset.map(function (pt) {
+              /*jslint evil: true */
+              var _getObj = new Function(
+                "pt",
+                "var o = {}; o" +
+                  format[0] +
+                  "= pt[0]; o" +
+                  format[1] +
+                  "= pt[1]; return o;"
+              );
+              return _getObj(pt);
+            });
+          }
+
+          function _sortByX(pointset) {
+            return pointset.sort(function (a, b) {
+              if (a[0] == b[0]) {
+                return a[1] - b[1];
+              } else {
+                return a[0] - b[0];
+              }
+            });
+          }
+
+          function _getMaxY(pointset) {
+            var maxY = -Infinity;
+            for (var i = pointset.length - 1; i >= 0; i--) {
+              if (pointset[i][1] > maxY) {
+                maxY = pointset[i][1];
+              }
+            }
+            return maxY;
+          }
+
+          function _upperTangent(pointset) {
+            var lower = [];
+            for (var l = 0; l < pointset.length; l++) {
+              while (
+                lower.length >= 2 &&
+                _cross(
+                  lower[lower.length - 2],
+                  lower[lower.length - 1],
+                  pointset[l]
+                ) <= 0
+              ) {
+                lower.pop();
+              }
+              lower.push(pointset[l]);
+            }
+            lower.pop();
+            return lower;
+          }
+
+          function _lowerTangent(pointset) {
+            var reversed = pointset.reverse(),
+              upper = [];
+            for (var u = 0; u < reversed.length; u++) {
+              while (
+                upper.length >= 2 &&
+                _cross(
+                  upper[upper.length - 2],
+                  upper[upper.length - 1],
+                  reversed[u]
+                ) <= 0
+              ) {
+                upper.pop();
+              }
+              upper.push(reversed[u]);
+            }
+            upper.pop();
+            return upper;
+          }
+
+          function _cross(o, a, b) {
+            return (
+              (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
+            );
+          }
+
+          function _sqLength(a, b) {
+            return Math.pow(b[0] - a[0], 2) + Math.pow(b[1] - a[1], 2);
+          }
+
+          function _cos(o, a, b) {
+            var aShifted = [a[0] - o[0], a[1] - o[1]],
+              bShifted = [b[0] - o[0], b[1] - o[1]],
+              sqALen = _sqLength(o, a),
+              sqBLen = _sqLength(o, b),
+              dot = aShifted[0] * bShifted[0] + aShifted[1] * bShifted[1];
+
+            return dot / Math.sqrt(sqALen * sqBLen);
+          }
+
+          function _intersect(segment, pointset) {
+            for (var i = 0; i < pointset.length - 1; i++) {
+              var seg = [pointset[i], pointset[i + 1]];
+              if (
+                (segment[0][0] === seg[0][0] && segment[0][1] === seg[0][1]) ||
+                (segment[0][0] === seg[1][0] && segment[0][1] === seg[1][1])
+              ) {
+                continue;
+              }
+              if (intersect(segment, seg)) {
+                return true;
+              }
+            }
+            return false;
+          }
+
+          function _bBoxAround(edge, boxSize) {
+            var minX, maxX, minY, maxY;
+
+            if (edge[0][0] < edge[1][0]) {
+              minX = edge[0][0] - boxSize;
+              maxX = edge[1][0] + boxSize;
+            } else {
+              minX = edge[1][0] - boxSize;
+              maxX = edge[0][0] + boxSize;
+            }
+
+            if (edge[0][1] < edge[1][1]) {
+              minY = edge[0][1] - boxSize;
+              maxY = edge[1][1] + boxSize;
+            } else {
+              minY = edge[1][1] - boxSize;
+              maxY = edge[0][1] + boxSize;
+            }
+
+            return [
+              minX,
+              minY, // tl
+              maxX,
+              maxY, // br
+            ];
+          }
+
+          function _midPoint(edge, innerPoints, convex) {
+            var point = null,
+              angle1Cos = MAX_CONCAVE_ANGLE_COS,
+              angle2Cos = MAX_CONCAVE_ANGLE_COS,
+              a1Cos,
+              a2Cos;
+
+            for (var i = 0; i < innerPoints.length; i++) {
+              a1Cos = _cos(edge[0], edge[1], innerPoints[i]);
+              a2Cos = _cos(edge[1], edge[0], innerPoints[i]);
+
+              if (
+                a1Cos > angle1Cos &&
+                a2Cos > angle2Cos &&
+                !_intersect([edge[0], innerPoints[i]], convex) &&
+                !_intersect([edge[1], innerPoints[i]], convex)
+              ) {
+                angle1Cos = a1Cos;
+                angle2Cos = a2Cos;
+                point = innerPoints[i];
+              }
+            }
+
+            return point;
+          }
+
+          function _concave(convex, maxSqEdgeLen, maxSearchBBoxSize, grid) {
+            var edge,
+              border,
+              bBoxSize,
+              midPoint,
+              bBoxAround,
+              midPointInserted = false;
+
+            for (var i = 0; i < convex.length - 1; i++) {
+              edge = [convex[i], convex[i + 1]];
+
+              if (_sqLength(edge[0], edge[1]) < maxSqEdgeLen) {
+                continue;
+              }
+
+              border = 0;
+              bBoxSize = MIN_SEARCH_BBOX_SIZE;
+              bBoxAround = _bBoxAround(edge, bBoxSize);
+              do {
+                bBoxAround = grid.addBorder2Bbox(bBoxAround, border);
+                bBoxSize = bBoxAround[2] - bBoxAround[0];
+                midPoint = _midPoint(
+                  edge,
+                  grid.rangePoints(bBoxAround),
+                  convex
+                );
+                border++;
+              } while (midPoint === null && maxSearchBBoxSize > bBoxSize);
+
+              if (midPoint !== null) {
+                convex.splice(i + 1, 0, midPoint);
+                grid.removePoint(midPoint);
+                midPointInserted = true;
+              }
+            }
+
+            if (midPointInserted) {
+              return _concave(convex, maxSqEdgeLen, maxSearchBBoxSize, grid);
+            }
+
+            return convex;
+          }
+
+          function hull(pointset, concavity, format) {
+            var lower,
+              upper,
+              convex,
+              innerPoints,
+              maxSearchBBoxSize,
+              maxEdgeLen = concavity || 20;
+
+            if (pointset.length < 4) {
+              return pointset;
+            }
+
+            pointset = _sortByX(_formatToXy(pointset, format));
+            upper = _upperTangent(pointset);
+            lower = _lowerTangent(pointset);
+            convex = lower.concat(upper);
+            convex.push(pointset[0]);
+
+            maxSearchBBoxSize =
+              Math.max(pointset[pointset.length - 1][0], _getMaxY(convex)) *
+              MAX_SEARCH_BBOX_SIZE_PERCENT;
+            innerPoints = pointset.filter(function (pt) {
+              return convex.indexOf(pt) < 0;
+            });
+
+            return _xyToFormat(
+              _concave(
+                convex,
+                Math.pow(maxEdgeLen, 2),
+                maxSearchBBoxSize,
+                grid(innerPoints)
+              ),
+              format
+            );
+          }
+
+          var MAX_CONCAVE_ANGLE_COS = Math.cos(90 / (180 / Math.PI)); // angle = 90 deg
+          var MIN_SEARCH_BBOX_SIZE = 5;
+          var MAX_SEARCH_BBOX_SIZE_PERCENT = 0.8;
+
+          module.exports = hull;
+        },
+        { "./grid.js": 1, "./intersect.js": 3 },
+      ],
+      3: [
+        function (require, module, exports) {
+          function ccw(x1, y1, x2, y2, x3, y3) {
+            var cw = (y3 - y1) * (x2 - x1) - (y2 - y1) * (x3 - x1);
+            return cw > 0 ? true : cw < 0 ? false : true; // colinear
+          }
+
+          function intersect(seg1, seg2) {
+            var x1 = seg1[0][0],
+              y1 = seg1[0][1],
+              x2 = seg1[1][0],
+              y2 = seg1[1][1],
+              x3 = seg2[0][0],
+              y3 = seg2[0][1],
+              x4 = seg2[1][0],
+              y4 = seg2[1][1];
+            return (
+              ccw(x1, y1, x3, y3, x4, y4) !== ccw(x2, y2, x3, y3, x4, y4) &&
+              ccw(x1, y1, x2, y2, x3, y3) !== ccw(x1, y1, x2, y2, x4, y4)
+            );
+          }
+
+          module.exports = intersect;
+        },
+        {},
+      ],
+    },
+    {},
+    [2]
+  )(2);
+});

package/ExternalLibraries/i18n.min.js

@@ -0,0 +1,115 @@
+/**
+ * @license RequireJS i18n 2.0.6 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/i18n for details
+ */
+/*jslint regexp: true */
+/*global require: false, navigator: false, define: false */
+
+/**
+ * This plugin handles i18n! prefixed modules. It does the following:
+ *
+ * 1) A regular module can have a dependency on an i18n bundle, but the regular
+ * module does not want to specify what locale to load. So it just specifies
+ * the top-level bundle, like 'i18n!nls/colors'.
+ *
+ * This plugin will load the i18n bundle at nls/colors, see that it is a root/master
+ * bundle since it does not have a locale in its name. It will then try to find
+ * the best match locale available in that master bundle, then request all the
+ * locale pieces for that best match locale. For instance, if the locale is 'en-us',
+ * then the plugin will ask for the 'en-us', 'en' and 'root' bundles to be loaded
+ * (but only if they are specified on the master bundle).
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/colors bundle to be that mixed in locale.
+ *
+ * 2) A regular module specifies a specific locale to load. For instance,
+ * i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
+ * first, at nls/colors, then figure out what the best match locale is for fr-fr,
+ * since maybe only fr or just root is defined for that locale. Once that best
+ * fit is found, all of its locale pieces need to have their bundles loaded.
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/fr-fr/colors bundle to be that mixed in locale.
+ */
+!(function () {
+  "use strict";
+  function o(o, n, e, a, t, r) {
+    n[o] && (e.push(o), (n[o] === !0 || 1 === n[o]) && a.push(t + o + "/" + r));
+  }
+  function n(o, n, e, a, t) {
+    var r = a + n + "/" + t;
+    require._fileExists(o.toUrl(r + ".js")) && e.push(r);
+  }
+  function e(o, n, a) {
+    var t;
+    for (t in n)
+      !n.hasOwnProperty(t) || (o.hasOwnProperty(t) && !a)
+        ? "object" == typeof n[t] &&
+          (!o[t] && n[t] && (o[t] = {}), e(o[t], n[t], a))
+        : (o[t] = n[t]);
+  }
+  var a = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/;
+  define(["module"], function (t) {
+    var r = t.config ? t.config() : {};
+    return {
+      version: "2.0.6",
+      load: function (t, i, l, u) {
+        (u = u || {}), u.locale && (r.locale = u.locale);
+        var f,
+          s,
+          c,
+          g = a.exec(t),
+          v = g[1],
+          p = g[4],
+          h = g[5],
+          d = p.split("-"),
+          y = [],
+          w = {},
+          j = "";
+        if (
+          (g[5]
+            ? ((v = g[1]), (f = v + h))
+            : ((f = t),
+              (h = g[4]),
+              (p = r.locale),
+              p ||
+                (p = r.locale =
+                  "undefined" == typeof navigator
+                    ? "root"
+                    : (
+                        (navigator.languages && navigator.languages[0]) ||
+                        navigator.language ||
+                        navigator.userLanguage ||
+                        "root"
+                      ).toLowerCase()),
+              (d = p.split("-"))),
+          u.isBuild)
+        ) {
+          for (y.push(f), n(i, "root", y, v, h), s = 0; s < d.length; s++)
+            (c = d[s]), (j += (j ? "-" : "") + c), n(i, j, y, v, h);
+          i(y, function () {
+            l();
+          });
+        } else
+          i([f], function (n) {
+            var a,
+              t = [];
+            for (o("root", n, t, y, v, h), s = 0; s < d.length; s++)
+              (a = d[s]), (j += (j ? "-" : "") + a), o(j, n, t, y, v, h);
+            i(y, function () {
+              var o, a, r;
+              for (o = t.length - 1; o > -1 && t[o]; o--)
+                (r = t[o]),
+                  (a = n[r]),
+                  (a === !0 || 1 === a) && (a = i(v + r + "/" + h)),
+                  e(w, a);
+              l(w);
+            });
+          });
+      },
+    };
+  });
+})();

package/ExternalLibraries/jquery-ui-timepicker-addon.min.css

@@ -0,0 +1,76 @@
+/*! jQuery Timepicker Addon - v1.5.5 - 2015-05-24
+* http://trentrichardson.com/examples/timepicker
+* Copyright (c) 2015 Trent Richardson;Licensed MIT */
+.ui-timepicker-div .ui-widget-header {
+  margin-bottom: 8px;
+}
+.ui-timepicker-div dl {
+  text-align: left;
+}
+.ui-timepicker-div dl dt {
+  float: left;
+  clear: left;
+  padding: 0 0 0 5px;
+}
+.ui-timepicker-div dl dd {
+  margin: 0 10px 10px 40%;
+}
+.ui-timepicker-div td {
+  font-size: 90%;
+}
+.ui-tpicker-grid-label {
+  background: 0 0;
+  border: 0;
+  margin: 0;
+  padding: 0;
+}
+.ui-timepicker-div .ui_tpicker_unit_hide {
+  display: none;
+}
+.ui-timepicker-rtl {
+  direction: rtl;
+}
+.ui-timepicker-rtl dl {
+  text-align: right;
+  padding: 0 5px 0 0;
+}
+.ui-timepicker-rtl dl dt {
+  float: right;
+  clear: right;
+}
+.ui-timepicker-rtl dl dd {
+  margin: 0 40% 10px 10px;
+}
+.ui-timepicker-div.ui-timepicker-oneLine {
+  padding-right: 2px;
+}
+.ui-timepicker-div.ui-timepicker-oneLine .ui_tpicker_time,
+.ui-timepicker-div.ui-timepicker-oneLine dt {
+  display: none;
+}
+.ui-timepicker-div.ui-timepicker-oneLine .ui_tpicker_time_label {
+  display: block;
+  padding-top: 2px;
+}
+.ui-timepicker-div.ui-timepicker-oneLine dl {
+  text-align: right;
+}
+.ui-timepicker-div.ui-timepicker-oneLine dl dd,
+.ui-timepicker-div.ui-timepicker-oneLine dl dd > div {
+  display: inline-block;
+  margin: 0;
+}
+.ui-timepicker-div.ui-timepicker-oneLine dl dd.ui_tpicker_minute:before,
+.ui-timepicker-div.ui-timepicker-oneLine dl dd.ui_tpicker_second:before {
+  content: ":";
+  display: inline-block;
+}
+.ui-timepicker-div.ui-timepicker-oneLine dl dd.ui_tpicker_millisec:before,
+.ui-timepicker-div.ui-timepicker-oneLine dl dd.ui_tpicker_microsec:before {
+  content: ".";
+  display: inline-block;
+}
+.ui-timepicker-div.ui-timepicker-oneLine .ui_tpicker_unit_hide,
+.ui-timepicker-div.ui-timepicker-oneLine .ui_tpicker_unit_hide:before {
+  display: none;
+}