@ms-atlas-module/datastudio-datafactory 0.1.36

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Util/Resize.js

@@ -0,0 +1,241 @@
+/// <reference path="../../Definitions/jquery.d.ts" />
+define([
+  "require",
+  "exports",
+  "./Detection",
+  "../Base/Base.TriggerableLifetimeManager",
+], function (require, exports, Detection, BaseTriggerableLifetimeManager) {
+  var Main;
+  (function (Main) {
+    "use strict";
+    var global = window,
+      $ = jQuery;
+    /**
+     * Hooks up cross browser resize detection event (ie, webkit, moz).
+     *
+     * @param element The element to monitor size changes.
+     * @param handler The resize event handler.
+     * @return The method to dispose the event.
+     */
+    function track(element, handler) {
+      var width,
+        height,
+        elem,
+        resizeHandler,
+        resizeElement,
+        overflowEvent,
+        underflowEvent,
+        overflowHandler,
+        underflowHandler,
+        reset,
+        position,
+        overflowElement,
+        underflowElement,
+        overflowContentElement,
+        underflowContentElement;
+      // Don't allow multiple uses
+      if (
+        element.children(".azc-resize").length ||
+        element.children(".azc-overflow").length ||
+        element.children(".azc-underflow").length
+      ) {
+        throw new Error(
+          "Resize tracker may only be attached once to an element."
+        );
+      }
+      // Save the initial state
+      width = element.width();
+      height = element.height();
+      // Handles geting the current sizes and calling the provided handler.
+      resizeHandler = function () {
+        var currentWidth = element.width(),
+          currentHeight = element.height();
+        if (currentHeight !== height || currentWidth !== width) {
+          width = currentWidth;
+          height = currentHeight;
+          handler(width, height);
+        }
+      };
+      var lifetime =
+        new BaseTriggerableLifetimeManager.TriggerableLifetimeManager();
+      Detection.Detection.Features.Events.complete().then(function () {
+        if (Detection.Detection.Features.Events.divResize) {
+          var attachmentTarget = element[0];
+          // IE 10- only supports onresize with attachEvent
+          attachmentTarget.attachEvent("onresize", resizeHandler);
+          // Register the detach for disposal
+          lifetime.registerForDispose({
+            dispose: function () {
+              attachmentTarget.detachEvent("onresize", resizeHandler);
+            },
+          });
+          return lifetime;
+        } else if (Detection.Detection.Features.Events.svgResize) {
+          // IE 11 supports onresize on svg if there is an onresize attribute
+          element.append(
+            "<svg class='azc-resize' onresize='' style='position:absolute; left: 0; top:0; width:100%; height:100%; z-index:-1'></svg>"
+          );
+          resizeElement = element.children(".azc-resize");
+          resizeElement[0].onresize = resizeHandler;
+          // If the element is not positioned make it relative
+          // so that the detection svg can use absolute positioning
+          position = element.css("position");
+          if (position === "static") {
+            element.css("position", "relative");
+          }
+          // Register the detector for disposal
+          lifetime.registerForDispose({
+            dispose: function () {
+              resizeElement.remove();
+              // Restore original position
+              if (position === "static") {
+                element.css("position", position);
+              }
+            },
+          });
+          return lifetime;
+        } else if (Detection.Detection.Features.Events.overflowchanged) {
+          // Webkit supports overflowchanged event with event parameters to distinguish overflow/underflow.
+          overflowEvent = "overflowchanged";
+          underflowEvent = "overflowchanged";
+          overflowHandler = function (evt) {
+            if (
+              evt.originalEvent &&
+              (evt.originalEvent.horizontalOverflow === true ||
+                evt.originalEvent.verticalOverflow === true)
+            ) {
+              resizeHandler();
+              reset();
+            }
+          };
+          underflowHandler = function (evt) {
+            if (
+              evt.originalEvent &&
+              (evt.originalEvent.horizontalOverflow === false ||
+                evt.originalEvent.verticalOverflow === false)
+            ) {
+              resizeHandler();
+              reset();
+            }
+          };
+        } else if (
+          Detection.Detection.Features.Events.overflow &&
+          Detection.Detection.Features.Events.underflow
+        ) {
+          // Mozilla supports overflow/underflow events
+          overflowEvent = "overflow";
+          underflowEvent = "underflow";
+          overflowHandler = function (evt) {
+            resizeHandler();
+            reset();
+          };
+          underflowHandler = function (evt) {
+            resizeHandler();
+            reset();
+          };
+        } else if (Detection.Detection.Features.Events.objResize) {
+          // If the element is not positioned make it relative
+          // so that the detection svg can use absolute positioning
+          position = element.css("position");
+          if (position === "static") {
+            element.css("position", "relative");
+          }
+          // Use resize event of object tag
+          element.append(
+            "<object class='azc-resize' type='text/html' style='position:absolute; left: 0; top:0; width:100%; height:100%; z-index:-1'></object>"
+          );
+          resizeElement = element.children(".azc-resize");
+          var obj = resizeElement[0];
+          resizeElement.on("load", function () {
+            obj.contentDocument.defaultView.addEventListener(
+              "resize",
+              resizeHandler
+            );
+          });
+          // Cause a load
+          obj.data = "about:blank";
+          // Register the detector for disposal
+          lifetime.registerForDispose({
+            dispose: function () {
+              resizeElement.remove();
+              // Restore original position
+              if (position === "static") {
+                element.css("position", position);
+              }
+            },
+          });
+          return lifetime;
+        } else {
+          // Unable to detect element resize changes in current browser.
+          // Instead we will do it on window changes
+          // This is imperfect but should always be present
+          window.addEventListener("resize", resizeHandler);
+          // Register the removal for disposal
+          lifetime.registerForDispose({
+            dispose: function () {
+              window.removeEventListener("resize", resizeHandler);
+            },
+          });
+          return lifetime;
+        }
+        // Resets the overflow and underflow detection element sizes.
+        reset = function () {
+          // Put the overflowElement in an underflow state such that an increase of 1px will cause an overflow.
+          overflowContentElement.width(width);
+          overflowContentElement.height(height);
+          // Puts the underflowElement in an overflow state such that a decrease of 1px will cause an underflow.
+          underflowContentElement.width(width + 1);
+          underflowContentElement.height(height + 1);
+        };
+        // If the element is not positioned make it relative
+        // so that the detection elements can use absolute positioning
+        position = element.css("position");
+        if (position === "static") {
+          element.css("position", "relative");
+        }
+        // Append the overflow/underflow detection elements
+        element.append(
+          "<div class='azc-underflow' style='position:absolute; left: 0; top:0; width:100%; height:100%; overflow:hidden; z-index:-1'>" +
+            "<div class='azc-underflow-content'></div>" +
+            "</div>" +
+            "<div class='azc-overflow' style='position:absolute; left:0; top:0; width:100%; height:100%; overflow:hidden; z-index:-1'>" +
+            "<div class='azc-overflow-content'></div>" +
+            "</div>"
+        );
+        // Save the overflow/underflow detection elements
+        overflowElement = element.children(".azc-overflow");
+        underflowElement = element.children(".azc-underflow");
+        overflowContentElement = overflowElement.children(
+          ".azc-overflow-content"
+        );
+        underflowContentElement = underflowElement.children(
+          ".azc-underflow-content"
+        );
+        // Initialize the overflow/underflow detection elements
+        reset();
+        // Hook up the overflow/underflow events
+        overflowElement.on(overflowEvent, overflowHandler);
+        underflowElement.on(underflowEvent, underflowHandler);
+        // Register the detector for disposal
+        lifetime.registerForDispose({
+          dispose: function () {
+            // Unhook the overflow/underflow events
+            overflowElement.off(overflowEvent, overflowHandler);
+            underflowElement.off(underflowEvent, underflowHandler);
+            // Remove the overflow/underflow detection elements
+            overflowElement.remove();
+            underflowElement.remove();
+            // Restore original position
+            if (position === "static") {
+              element.css("position", position);
+            }
+          },
+        });
+        return lifetime;
+      });
+      return lifetime;
+    }
+    Main.track = track;
+  })(Main || (Main = {}));
+  return Main;
+});

package/libs/VivaGraphControl/Content/Scripts/Viva.Controls/Util/Util.Private.js

@@ -0,0 +1,236 @@
+/// <reference path="../../Definitions/hammer.d.ts" />
+define(["require", "exports"], function (require, exports) {
+  var Main;
+  (function (Main) {
+    "use strict";
+    // IE11- does not support custom types. We will store those types in the "Text" type with proper separators.
+    // However, we cannot read the "Text" type when we are NOT in a drop event. This is a problem when trying
+    // to read the "types" variable. So we save the types in a local variable when we setData with Text.
+    // This would cause a problem if someone is using the DataTransfer polyfill from a drag-n-drop not set with this polyfill.
+    // The data coming back from types would be empty.
+    var legacyDataTransfer = null,
+      savedTypes,
+      global = window;
+    var DataTransfer2 = (function () {
+      function DataTransfer2(dataTransfer) {
+        this._prefixCode = ";;;";
+        this._dataTransfer = dataTransfer;
+      }
+      Object.defineProperty(DataTransfer2.prototype, "dropEffect", {
+        get: function () {
+          return this._dataTransfer.dropEffect;
+        },
+        set: function (value) {
+          if (
+            value !== "none" &&
+            value !== "copy" &&
+            value !== "link" &&
+            value !== "move"
+          ) {
+            throw new Error(
+              "Drop effect must be either none, copy, link, or move."
+            );
+          }
+          this._dataTransfer.dropEffect = value;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      Object.defineProperty(DataTransfer2.prototype, "effectAllowed", {
+        get: function () {
+          return this._dataTransfer.effectAllowed;
+        },
+        set: function (value) {
+          if (
+            value !== "none" &&
+            value !== "copy" &&
+            value !== "copyLink" &&
+            value !== "copyMove" &&
+            value !== "link" &&
+            value !== "linkMove" &&
+            value !== "move" &&
+            value !== "all" &&
+            value !== "uninitialized"
+          ) {
+            throw new Error(
+              "Effect allowed must be either none, copy, copyLink, copyMove, link, linkMove, move, all, or uninitialized."
+            );
+          }
+          this._dataTransfer.effectAllowed = value;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      Object.defineProperty(DataTransfer2.prototype, "types", {
+        get: function () {
+          // TODO TypeScript 0.9.5, Need to cast, lib.d.ts is incorrect
+          var types = this._dataTransfer.types,
+            i,
+            hasType,
+            legacyData,
+            temporaryTypes;
+          // If we never checked for legacy, let's do it now
+          if (legacyDataTransfer === null) {
+            this.getData("");
+          }
+          // Let's check now if we need to reconstruct the types (IE11-)
+          if (legacyDataTransfer) {
+            // In IE, we might not be able to call getText depending on the event we are
+            // In this case, we will pick savedTypes.
+            // However, using the savedTypes from a drag-n-drop not using this polyfill would give stale data.
+            hasType = false;
+            legacyData = this._getLegacyData();
+            for (var type in legacyData) {
+              if (legacyData.hasOwnProperty(type) && legacyData[type] !== "") {
+                hasType = true;
+                break;
+              }
+            }
+            return Object.keys(hasType ? legacyData : savedTypes);
+          }
+          if (types) {
+            // Some browsers don't have the types as an array (IE11- & Firefox)
+            if (!types["forEach"]) {
+              temporaryTypes = types;
+              types = [];
+              for (i = 0; i < temporaryTypes.length; i++) {
+                types.push(temporaryTypes[i]);
+              }
+            }
+          }
+          return types;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      Object.defineProperty(DataTransfer2.prototype, "files", {
+        get: function () {
+          return this._dataTransfer.files;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+      /**
+       * Returns true if the script detected that the transfer is using a legacy system.
+       *
+       * @return True if legacy is used.
+       */
+      DataTransfer2.isLegacyDataTransfer = function () {
+        // If we never checked for legacyDataTransfer, let's make a guess with a method.
+        if (legacyDataTransfer === null) {
+          // TODO TypeScript 0.9.5: setDragImage doesn't exist in lib.d.ts
+          // Browsers are not set yet on the name of the class. Chrome uses Clipboard, the others use DataTransfer.
+          var dataTransferVariable =
+            global["DataTransfer"] || global["Clipboard"];
+          return !dataTransferVariable.prototype["setDragImage"];
+        }
+        return legacyDataTransfer;
+      };
+      DataTransfer2.prototype.setDragImage = function (image, x, y) {
+        if (this._dataTransfer["setDragImage"]) {
+          this._dataTransfer["setDragImage"](image, x, y);
+        }
+      };
+      DataTransfer2.prototype.addElement = function (element) {
+        if (this._dataTransfer["addElement"]) {
+          this._dataTransfer["addElement"](element);
+        }
+      };
+      DataTransfer2.prototype.getData = function (format) {
+        this._checkFormat(format);
+        if (legacyDataTransfer) {
+          return this._getLegacyDataTransfer(format);
+        } else {
+          try {
+            legacyDataTransfer = false;
+            return this._dataTransfer.getData(format);
+          } catch (ex) {
+            // The browser doesn't support custom mime type (IE11-)
+            legacyDataTransfer = true;
+            return this.getData(format);
+          }
+        }
+      };
+      DataTransfer2.prototype.setData = function (format, data) {
+        this._checkFormat(format);
+        if (legacyDataTransfer) {
+          this._setLegacyDataTransfer(format, data);
+        } else {
+          try {
+            legacyDataTransfer = false;
+            this._dataTransfer.setData(format, data);
+          } catch (ex) {
+            // The browser doesn't support custom mime type (IE11-)
+            legacyDataTransfer = true;
+            this.setData(format, data);
+          }
+        }
+      };
+      DataTransfer2.prototype.clearData = function (format) {
+        this._checkFormat(format);
+        if (legacyDataTransfer) {
+          this._clearLegacyDataTransfer(format);
+        } else {
+          try {
+            legacyDataTransfer = false;
+            this._dataTransfer.clearData(format);
+          } catch (ex) {
+            // The browser doesn't support custom mime type (IE11-)
+            legacyDataTransfer = true;
+            this.clearData(format);
+          }
+        }
+      };
+      DataTransfer2.prototype._checkFormat = function (format) {
+        if (format && format.toLowerCase() !== format) {
+          throw new Error("Format must be in lowercase.");
+        }
+      };
+      DataTransfer2.prototype._getLegacyData = function () {
+        var allData = this._dataTransfer.getData("Text");
+        if (allData) {
+          if (allData.substr(0, this._prefixCode.length) === this._prefixCode) {
+            return JSON.parse(allData.substr(this._prefixCode.length));
+          }
+        }
+        return { Text: allData };
+      };
+      DataTransfer2.prototype._stringifyLegacyData = function (allData) {
+        return this._prefixCode + JSON.stringify(allData);
+      };
+      DataTransfer2.prototype._getLegacyDataTransfer = function (format) {
+        return this._getLegacyData()[format] || "";
+      };
+      DataTransfer2.prototype._setLegacyDataTransfer = function (format, data) {
+        var allData = this._getLegacyData();
+        allData[format] = data;
+        // Let's save the type... IE11 cannot read the types in a dragover event
+        savedTypes = allData;
+        this._dataTransfer.setData("Text", this._stringifyLegacyData(allData));
+      };
+      DataTransfer2.prototype._clearLegacyDataTransfer = function (format) {
+        savedTypes = {};
+        if (format) {
+          var allData = this._getLegacyData();
+          delete allData[format];
+          savedTypes = allData;
+        }
+        this._dataTransfer.setData(
+          "Text",
+          this._stringifyLegacyData(savedTypes)
+        );
+      };
+      return DataTransfer2;
+    })();
+    Main.DataTransfer2 = DataTransfer2;
+    // We need to clear the saved types once the dragend is emited.
+    document.addEventListener(
+      "dragend",
+      function () {
+        savedTypes = {};
+      },
+      false
+    );
+  })(Main || (Main = {}));
+  return Main;
+});