@ms-atlas-module/datastudio-datafactory 0.1.36

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Controls/DockedBalloon.js

@@ -0,0 +1,18 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var Main;
+  (function (Main) {
+    Main.classes = {
+      widget: "azc-dockedballoon",
+    };
+    function DismissAllBalloons() {}
+    Main.DismissAllBalloons = DismissAllBalloons;
+    var DockedBalloon = (function () {
+      function DockedBalloon() {}
+      return DockedBalloon;
+    })();
+    Main.DockedBalloon = DockedBalloon;
+  })(Main || (Main = {}));
+  return Main;
+});
+//# sourceMappingURL=DockedBalloon.js.map

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Controls/Visualization/Graph/Animation.js

@@ -0,0 +1,192 @@
+define(["require", "exports", "./GraphWidget.Constants"], function (
+  require,
+  exports,
+  ConstantsGraphWidget
+) {
+  var Main;
+  (function (Main) {
+    "use strict";
+    var global = window;
+    /**
+     * The function used to get the current time. Tests can inject their own method and control time in
+     * a more rigorous manner.
+     */
+    Main.getCurrentTime = Date.now;
+    /**
+     * The function used to call a function after a certain amount of time. Tests can inject their own method and control time in
+     * a more rigorous manner.
+     */
+    Main.setTimeoutFromCurrentTime = setTimeout.bind(window);
+    /**
+     * A class that manages frame tweening for animating numeric properties.
+     */
+    var Animation = (function () {
+      /**
+       * Creates an animation that tweens some collection of values between start and end values.
+       *
+       * @param stepFunction callback for every frame of the animation
+       * @param animatedProperties a dictionary where the key is the name of the animated property and its value contains the start and end values.
+       * @param duration the length of the animation in milliseconds
+       * @param easingFunction a Callback that maps time to percentage complete for the animation.
+       */
+      function Animation(
+        stepFunction,
+        animatedProperties,
+        duration,
+        easingFunction
+      ) {
+        if (duration === void 0) {
+          duration = 800;
+        }
+        if (easingFunction === void 0) {
+          easingFunction = Animation._defaultEasing;
+        }
+        this._easingFunction = easingFunction;
+        this._duration = duration;
+        this._startTime = Main.getCurrentTime();
+        this._endTime = this._startTime + duration;
+        this._stepFunction = stepFunction;
+        this._animatedProperties = animatedProperties;
+        this.animationEnded = ko.observable(null);
+        this._animationStopped = false;
+        this._ignoreFrames = false;
+        for (var key in this._animatedProperties) {
+          if (isNaN(Number(animatedProperties[key].start))) {
+            throw (
+              "The property " + key + " lacks a numerical animation start value"
+            );
+          }
+          if (
+            isNaN(
+              Number(ko.utils.unwrapObservable(animatedProperties[key].end))
+            )
+          ) {
+            throw (
+              "The property " + key + " lacks a numerical animation end value"
+            );
+          }
+        }
+      }
+      Object.defineProperty(Animation, "requestAnimationFramePolyfill", {
+        /**
+         * A polyfill for requestAnimationFrame
+         */
+        get: function () {
+          var polyfill =
+            global.requestAnimationFrame ||
+            global.mozRequestAnimationFrame ||
+            global.webkitRequestAnimationFrame ||
+            global.msRequestAnimationFrame;
+          if (!polyfill) {
+            polyfill = function (callback) {
+              return setTimeout(callback, ConstantsGraphWidget.SixtyFPS);
+            };
+          }
+          // requestAnimationFrame will throw an illegal invocation error if 'this' isn't window.
+          return polyfill.bind(window);
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      Object.defineProperty(Animation, "cancelAnimationFramePolyfill", {
+        get: function () {
+          // TSLint complains if we name this polyfill
+          var polyfill2 =
+            global.cancelAnimationFrame ||
+            global.msCancelRequestAnimationFrame ||
+            global.webkitCancelAnimationFrame ||
+            global.mozCancelAnimationFrame;
+          if (!polyfill2) {
+            polyfill2 = clearTimeout;
+          }
+          return polyfill2.bind(window);
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      // We use this to avoid versioning issues with jquery's swing function
+      Animation._defaultEasing = function (percentTime) {
+        return (Math.sin((percentTime - 0.5) * Math.PI) + 1) / 2;
+      };
+      /**
+       * Starts the animation.
+       */
+      Animation.prototype.start = function () {
+        var _this = this;
+        if (this._animationStopped) {
+          throw new Error("Cannot start a previously stopped animation.");
+        }
+        Animation.requestAnimationFramePolyfill(function () {
+          _this._step();
+        });
+      };
+      /**
+       * Stops the animation
+       */
+      Animation.prototype.stop = function () {
+        if (this._animationStopped) {
+          throw new Error("Cannot stop an animation twice.");
+        }
+        this._animationStopped = true;
+        // Immediately fire the last frame so subscribers get notified immediately.
+        this._step();
+      };
+      Object.defineProperty(Animation.prototype, "animationStopped", {
+        /**
+         * Whether the animation is stopped (explicitly or the animation ended).
+         */
+        get: function () {
+          return this._animationStopped;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      Animation.prototype._step = function () {
+        var _this = this;
+        var percentTimeComplete =
+            (Main.getCurrentTime() - this._startTime) /
+            (this._endTime - this._startTime),
+          percentAnimationComplete =
+            percentTimeComplete < 1.0
+              ? this._easingFunction(percentTimeComplete)
+              : 1.0,
+          currentAnimationState = Object.create(null),
+          start,
+          end,
+          key;
+        // This prevents a race condition where we may have called requestAnimationFrame before calling stop
+        // meaning step will get called again. This ensures that the last frame that does anything is
+        // the one immediately proceeding .stop()
+        if (this._ignoreFrames) {
+          return;
+        }
+        for (key in this._animatedProperties) {
+          start = Number(this._animatedProperties[key].start);
+          end = Number(
+            ko.utils.unwrapObservable(this._animatedProperties[key].end)
+          );
+          currentAnimationState[key] =
+            start + (end - start) * percentAnimationComplete;
+        }
+        // If we stopped the animation (for completion or otherwise), make sure we don't call step again
+        // and notify subscribers that the animation ended
+        if (this._animationStopped) {
+          this.animationEnded.notifySubscribers(currentAnimationState);
+          this._ignoreFrames = true;
+          return;
+        }
+        this._stepFunction(currentAnimationState);
+        if (percentTimeComplete < 1.0) {
+          Animation.requestAnimationFramePolyfill(function () {
+            _this._step();
+          });
+        } else {
+          this.stop();
+        }
+      };
+      return Animation;
+    })();
+    Main.Animation = Animation;
+  })(Main || (Main = {}));
+  return Main;
+});

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Controls/Visualization/Graph/Commands/MoveNodes.js

@@ -0,0 +1,83 @@
+define(["require", "exports", "../GraphWidget.Constants"], function (
+  require,
+  exports,
+  ConstantsGraphWidget
+) {
+  var Main;
+  (function (Main) {
+    "use strict";
+    /**
+     * A command that moves graph nodes on activation/undo
+     */
+    var MoveNodesCommand = (function () {
+      /**
+       * Creates a command that moves graph nodes.
+       *
+       * @param nodes a list of the nodes to move
+       * @param oldLocations the original locations of the nodes. Needed for undo.
+       * @param newLocation where the nodes should move.
+       */
+      function MoveNodesCommand(nodes, oldLocations, newLocations) {
+        this._nodes = nodes;
+        this._oldLocations = oldLocations;
+        this._newLocations = newLocations;
+        this.undone = false;
+      }
+      /**
+       * Moves the nodes by comitting the new location to the view model.
+       */
+      MoveNodesCommand.prototype.run = function () {
+        for (var i = 0; i < this._nodes.length; i++) {
+          this._nodes[i].commit(
+            this._newLocations[i].x,
+            this._newLocations[i].y,
+            this._newLocations[i].width,
+            this._newLocations[i].height
+          );
+          // if we need to animate
+          if (this.undone) {
+            this._nodes[i].revertStatic(
+              ConstantsGraphWidget.UndoAnimationDuration
+            );
+          }
+        }
+        this.undone = false;
+      };
+      /**
+       * Moves the nodes to their original location by comitting to the view model.
+       */
+      MoveNodesCommand.prototype.undo = function () {
+        for (var i = 0; i < this._nodes.length; i++) {
+          this._nodes[i].commit(
+            this._oldLocations[i].x,
+            this._oldLocations[i].y,
+            this._oldLocations[i].width,
+            this._oldLocations[i].height
+          );
+          this._nodes[i].revertStatic(
+            ConstantsGraphWidget.RedoAnimationDuration
+          );
+        }
+        this.undone = true;
+      };
+      /**
+       * Appends to a pre-existing command.
+       * @param nodes a list of the nodes to move
+       * @param oldLocations the original locations of the nodes. Needed for undo.
+       * @param newLocation where the nodes should move.
+       */
+      MoveNodesCommand.prototype.update = function (
+        nodes,
+        oldLocations,
+        newLocations
+      ) {
+        this._nodes = nodes;
+        this._oldLocations = oldLocations;
+        this._newLocations = newLocations;
+      };
+      return MoveNodesCommand;
+    })();
+    Main.MoveNodesCommand = MoveNodesCommand;
+  })(Main || (Main = {}));
+  return Main;
+});

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Controls/Visualization/Graph/Geometry.js

@@ -0,0 +1,167 @@
+define(["require", "exports", "./GraphWidget.Constants"], function (
+  require,
+  exports,
+  GraphConstants
+) {
+  var Main;
+  (function (Main) {
+    "use strict";
+    /**
+     * Returns whether or not a completely lies in b
+     *
+     * @param a the rect to test for lying in b
+     * @param b the enclosing rect
+     * @return true if a lies completely in b. false otherwise.
+     */
+    function rectLiesInRect(a, b) {
+      return (
+        a.x + a.width <= b.x + b.width &&
+        a.x >= b.x &&
+        a.y + a.height <= b.y + b.height &&
+        a.y >= b.y
+      );
+    }
+    Main.rectLiesInRect = rectLiesInRect;
+    /**
+     * Returns the first point where the ray starting at p1 and ending at p2 intersects rect.
+     *
+     * @param p1 the start point for the line to test
+     * @param p2 the end point for the line to test
+     * @param rect the rectangle
+     * @return where the line and rectangle intersect on the exterior of the rectangle or null if they don't
+     */
+    function rayRectIntersection(p1, p2, rect) {
+      // Add padding to the rectangle so edges float a bit off it.
+      rect = {
+        x: rect.x - GraphConstants.NodeEdgePadding,
+        y: rect.y - GraphConstants.NodeEdgePadding,
+        height: rect.height + 2 * GraphConstants.NodeEdgePadding,
+        width: rect.width + 2 * GraphConstants.NodeEdgePadding,
+      };
+      // y = mx + b
+      var m = (p2.y - p1.y) / (p2.x - p1.x),
+        b = p1.y - m * p1.x,
+        rectRightX = rect.x + rect.width,
+        rectBottomY = rect.y + rect.height,
+        intersections,
+        x,
+        y,
+        minDSquared,
+        returnedPoint;
+      // A line can intersect a rectangle up to 2 times. We'll compute all intersections and return the one with the minimum distance to P1
+      intersections = [];
+      // Line is vertical, just check top and bottom lines of rectangle for intersection.
+      // This avoids dealing with colinear nonsense
+      if (Math.abs(m) === Infinity) {
+        if (Math.min(p1.y, p2.y) <= rect.y && Math.max(p1.y, p2.y) >= rect.y) {
+          intersections.push({
+            x: p1.x,
+            y: rect.y,
+          });
+        }
+        if (
+          Math.min(p1.y, p2.y) <= rectBottomY &&
+          Math.max(p1.y, p2.y) >= rectBottomY
+        ) {
+          intersections.push({
+            x: p1.x,
+            y: rectBottomY,
+          });
+        }
+      } else if (m === 0.0) {
+        if (Math.min(p1.x, p2.x) <= rect.x && Math.max(p1.x, p2.x) >= rect.x) {
+          intersections.push({
+            x: rect.x,
+            y: p1.y,
+          });
+        }
+        if (
+          Math.min(p1.x, p2.x) <= rectRightX &&
+          Math.max(p1.x, p2.x) >= rectRightX
+        ) {
+          intersections.push({
+            x: rectRightX,
+            y: p1.y,
+          });
+        }
+      } else {
+        // Does it intersect with left edge?
+        y = m * rect.x + b;
+        if (
+          y >= rect.y &&
+          y <= rectBottomY &&
+          Math.min(p1.x, p2.x) <= rect.x &&
+          rect.x <= Math.max(p1.x, p2.x) &&
+          Math.min(p1.y, p2.y) <= y &&
+          y <= Math.max(p1.y, p2.y)
+        ) {
+          intersections.push({
+            x: rect.x,
+            y: y,
+          });
+        }
+        // Does it intersect the right edge?
+        y = m * rectRightX + b;
+        if (
+          y >= rect.y &&
+          y <= rectBottomY &&
+          Math.min(p1.x, p2.x) <= rectRightX &&
+          rectRightX <= Math.max(p1.x, p2.x) &&
+          Math.min(p1.y, p2.y) <= y &&
+          y <= Math.max(p1.y, p2.y)
+        ) {
+          intersections.push({
+            x: rectRightX,
+            y: y,
+          });
+        }
+        //Does it intersect the top edge?
+        x = (rect.y - b) / m;
+        if (
+          x >= rect.x &&
+          x <= rectRightX &&
+          Math.min(p1.x, p2.x) <= x &&
+          x <= Math.max(p1.x, p2.x) &&
+          Math.min(p1.y, p2.y) <= rect.y &&
+          rect.y <= Math.max(p1.y, p2.y)
+        ) {
+          intersections.push({
+            x: x,
+            y: rect.y,
+          });
+        }
+        // Does it intersect the bottom edge?
+        x = (rectBottomY - b) / m;
+        if (
+          x >= rect.x &&
+          x <= rectRightX &&
+          Math.min(p1.x, p2.x) <= x &&
+          x <= Math.max(p1.x, p2.x) &&
+          Math.min(p1.y, p2.y) <= rectBottomY &&
+          rectBottomY <= Math.max(p1.y, p2.y)
+        ) {
+          intersections.push({
+            x: x,
+            y: rectBottomY,
+          });
+        }
+      }
+      minDSquared = Infinity;
+      returnedPoint = null;
+      // Because d = sqrt(dx^2 + dy^2), and dx and dy are real numbers, we're guaranteed the radical is positive. Thus,
+      // we can compare D^2 directly and forego the sqrt
+      intersections.forEach(function (point) {
+        var dx = point.x - p1.x,
+          dy = point.y - p1.y,
+          dSquared = dx * dx + dy * dy;
+        if (dSquared < minDSquared) {
+          minDSquared = dSquared;
+          returnedPoint = point;
+        }
+      });
+      return returnedPoint;
+    }
+    Main.rayRectIntersection = rayRectIntersection;
+  })(Main || (Main = {}));
+  return Main;
+});