@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/UI/Command.js

@@ -0,0 +1,231 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define(["require", "exports", "../Shared/Disposable"], function (
+  require,
+  exports,
+  Disposable
+) {
+  "use strict";
+  var ObservableCommand = (function (_super) {
+    __extends(ObservableCommand, _super);
+    function ObservableCommand(command) {
+      _super.call(this);
+      this.tooltip = ko.observable(null);
+      this.showCssTooltip = ko.observable(false);
+      this.onclick = ko.observable(null);
+      this.disabled = ko.observable(false);
+      this.selected = ko.observable(false);
+      this.icon = ko.observable(null);
+      this.name = ko.observable(null);
+      this.label = ko.observable(null);
+      this.buttonType = ko.observable("button");
+      this.keepFill = false;
+      if (command.tooltip) {
+        this.tooltip(command.tooltip);
+      }
+      if (command.showCssTooltip) {
+        this.showCssTooltip(command.showCssTooltip);
+      }
+      if (command.onclick) {
+        this.onclick(command.onclick);
+      }
+      if (command.disabled) {
+        this.disabled(command.disabled);
+      }
+      if (command.icon) {
+        this.icon(command.icon);
+      }
+      if (command.name) {
+        this.name(command.name);
+      }
+      if (command.label) {
+        this.label(command.label);
+      }
+      if (command.buttonType) {
+        this.buttonType(command.buttonType);
+      }
+      if (command.selected) {
+        this.selected(command.selected);
+      }
+      if (command.keepFill) {
+        this.keepFill = command.keepFill;
+      }
+    }
+    return ObservableCommand;
+  })(Disposable.RootDisposable);
+  exports.ObservableCommand = ObservableCommand;
+  var AppBarCommand = (function (_super) {
+    __extends(AppBarCommand, _super);
+    function AppBarCommand() {
+      _super.apply(this, arguments);
+      this.ibizaIcon = ko.observable(null);
+      this.updated = ko.observable(null).extend({ notify: "always" });
+    }
+    return AppBarCommand;
+  })(WinJS.UI.AppBarCommand);
+  exports.AppBarCommand = AppBarCommand;
+  var MenuCommand = (function (_super) {
+    __extends(MenuCommand, _super);
+    function MenuCommand() {
+      _super.apply(this, arguments);
+      this.updated = ko.observable(null).extend({ notify: "always" });
+    }
+    return MenuCommand;
+  })(WinJS.UI.MenuCommand);
+  exports.MenuCommand = MenuCommand;
+  var Button = (function (_super) {
+    __extends(Button, _super);
+    function Button(lifetimeManager, command) {
+      _super.call(this, lifetimeManager);
+      if (command instanceof ObservableCommand) {
+        this._command = command;
+      } else {
+        this._command = new ObservableCommand(command);
+      }
+    }
+    Button.removeCSS = function (element) {
+      element.find("[fill]").attr("class", "svg-fill").removeAttr("fill");
+      element.find("[stroke]").attr("class", "svg-stroke").removeAttr("stroke");
+      return element[0].outerHTML || $("<div></div>").append(element).html();
+    };
+    Button._captureMouseEvent = function (buttonElement) {
+      var handler = function (event) {
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        event.cancelBubble = true;
+      };
+      buttonElement.onmousedown = handler;
+      buttonElement.onmousemove = handler;
+      buttonElement.onmouseleave = handler;
+    };
+    Button.prototype.menuCommand = function (element) {
+      if (element === void 0) {
+        element = null;
+      }
+      var button = new MenuCommand(element, {
+        disabled: this._command.disabled(),
+        onclick: this._command.onclick(),
+        label: this._command.label(),
+        type: this._command.buttonType(),
+        tooltip: null,
+        showCssTooltip: this._command.showCssTooltip(),
+      });
+      button._command = this._command;
+      this._syncObservables(button);
+      this._syncObservableProperty(button, "tooltip");
+      return button;
+    };
+    Button.prototype.appBarCommand = function (element) {
+      var _this = this;
+      if (element === void 0) {
+        element = null;
+      }
+      var button = new AppBarCommand(element, {
+        disabled: this._command.disabled(),
+        onclick: this._command.onclick(),
+        label: this._command.label(),
+        type: this._command.buttonType(),
+        selected: this._command.selected(),
+        tooltip: null,
+        showCssTooltip: this._command.showCssTooltip(),
+      });
+      Button._captureMouseEvent(button.element);
+      button._command = this._command;
+      this._updateIcon(button);
+      this._syncObservables(button);
+      this._lifetimeManager.registerForDispose(
+        this._command.icon.subscribe(function (icon) {
+          _this._updateIcon(button);
+          button.updated(true);
+        })
+      );
+      this._lifetimeManager.registerForDispose(button);
+      return button;
+    };
+    Button.prototype._syncObservables = function (object) {
+      this._syncObservableProperty(object, "label");
+      this._syncObservableProperty(object, "onclick");
+      this._syncObservableProperty(object, "disabled");
+      this._syncObservableProperty(object, "selected");
+      this._syncObservableProperty(object, "buttonType", "type");
+      this._syncObservableProperty(object, "showCssTooltip");
+      this._addTooltip(object);
+    };
+    Button.prototype._syncObservableProperty = function (
+      object,
+      srcProperty,
+      destProperty
+    ) {
+      if (destProperty === void 0) {
+        destProperty = null;
+      }
+      if (!destProperty) {
+        destProperty = srcProperty;
+      }
+      var makeSubscription = function (_object, _destProperty) {
+        return function (value) {
+          _object[_destProperty] = value;
+          _object.updated(true);
+        };
+      };
+      this._lifetimeManager.registerForDispose(
+        this._command[srcProperty].subscribe(
+          makeSubscription(object, destProperty)
+        )
+      );
+    };
+    Button.prototype._addTooltip = function (object) {
+      if (object._command.showCssTooltip()) {
+        object.element.setAttribute("data-tooltip", this._command.tooltip());
+      } else {
+        object.element.title = this._command.tooltip();
+      }
+      this._lifetimeManager.registerForDispose(
+        object._command.tooltip.subscribe(function (value) {
+          if (object._command.showCssTooltip()) {
+            object.element.setAttribute("data-tooltip", value);
+          } else {
+            object.element.title = value;
+          }
+          object.updated(true);
+        })
+      );
+    };
+    Button.prototype._updateIcon = function (appBarCommand) {
+      if (!this._command.icon()) {
+        appBarCommand.icon = null;
+        appBarCommand.ibizaIcon(null);
+        appBarCommand.element.innerHTML = appBarCommand.label;
+        return;
+      }
+      appBarCommand.element.innerHTML = "";
+      if (typeof this._command.icon() === "string") {
+        appBarCommand.element.innerHTML = this._command.icon();
+        if (!this._command.keepFill) {
+          Button.removeCSS($(appBarCommand.element));
+        }
+        appBarCommand.ibizaIcon(null);
+        return;
+      }
+      appBarCommand.ibizaIcon(this._command.icon());
+      if (!$(appBarCommand.element).is("[data-bind]")) {
+        appBarCommand.element.setAttribute("data-bind", "image: icon()");
+        ko.applyBindings(
+          { icon: appBarCommand.ibizaIcon },
+          appBarCommand.element
+        );
+      }
+    };
+    return Button;
+  })(Disposable.ChildDisposable);
+  exports.Button = Button;
+});
+//# sourceMappingURL=Command.js.map

package/scripts/Framework/UI/ContextMenu.js

@@ -0,0 +1,80 @@
+define([
+  "require",
+  "exports",
+  "text!./Templates/ContextMenu.html",
+  "../Util/Log",
+], function (require, exports, contextMenuTemplate, Log) {
+  "use strict";
+  var contextMenuTemplate;
+  var logger = Log.getLogger({
+    loggerName: "ContextMenu",
+  });
+  var ContextMenu = (function () {
+    function ContextMenu() {
+      var _this = this;
+      this._hostElement = null;
+      this._contextMenuControl = null;
+      this._contextMenuPositionElement = null;
+      this._hostElement = $(contextMenuTemplate)[0];
+      var contextMenuWinJSHostDivSelector = ".contextMenuWinJSHostDiv";
+      var contextMenuPositionSelector = ".contextMenuPosition";
+      var contextMenuElement = this._hostElement.querySelector(
+        contextMenuWinJSHostDivSelector
+      );
+      WinJS.UI.processAll(contextMenuElement).then(
+        function (processedElement) {
+          _this._contextMenuControl = processedElement.winControl;
+          _this._contextMenuPositionElement = _this._hostElement.querySelector(
+            contextMenuPositionSelector
+          );
+        },
+        function (error) {
+          logger.logError(
+            "Failed to initialize context menu: ",
+            JSON.stringify(error)
+          );
+        }
+      );
+      var flyoutClickEater = $("body > section.win-flyoutmenuclickeater");
+      var preventContextMenuOnClickEater = function (event) {
+        event.preventDefault();
+      };
+      flyoutClickEater.on("contextmenu", preventContextMenuOnClickEater);
+      ko.utils.domNodeDisposal.addDisposeCallback(
+        this._hostElement,
+        function () {
+          if (_this._contextMenuControl) {
+            _this._contextMenuControl.dispose();
+          }
+          flyoutClickEater.off("contextmenu", preventContextMenuOnClickEater);
+        }
+      );
+    }
+    ContextMenu.createContextMenu = function (position, commandGroup) {
+      if (!ContextMenu._markupApplied) {
+        document.body.appendChild(ContextMenu._instance._hostElement);
+        ContextMenu._markupApplied = true;
+      }
+      var contextMenuControl = ContextMenu._instance._contextMenuControl;
+      var contextMenuPositionElement =
+        ContextMenu._instance._contextMenuPositionElement;
+      contextMenuControl.commands = commandGroup.commands;
+      var commandGroupCleanup = function () {
+        commandGroup.unbindViewModels();
+        contextMenuControl.removeEventListener(
+          "afterhide",
+          commandGroupCleanup
+        );
+      };
+      contextMenuControl.addEventListener("afterhide", commandGroupCleanup);
+      contextMenuPositionElement.style.top = position.clientY + "px";
+      contextMenuPositionElement.style.left = position.clientX + "px";
+      contextMenuControl.show(contextMenuPositionElement, "right");
+    };
+    ContextMenu._markupApplied = false;
+    ContextMenu._instance = new ContextMenu();
+    return ContextMenu;
+  })();
+  exports.ContextMenu = ContextMenu;
+});
+//# sourceMappingURL=ContextMenu.js.map

package/scripts/Framework/UI/Loader.js

@@ -0,0 +1,11 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  (function (LoadingState) {
+    LoadingState[(LoadingState["Loading"] = 0)] = "Loading";
+    LoadingState[(LoadingState["BlockingUiLoading"] = 1)] = "BlockingUiLoading";
+    LoadingState[(LoadingState["Failed"] = 2)] = "Failed";
+    LoadingState[(LoadingState["Ready"] = 3)] = "Ready";
+  })(exports.LoadingState || (exports.LoadingState = {}));
+  var LoadingState = exports.LoadingState;
+});
+//# sourceMappingURL=Loader.js.map

package/scripts/Framework/UI/Menu.js

@@ -0,0 +1,65 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define([
+  "require",
+  "exports",
+  "../Shared/Constants",
+  "../Shared/Disposable",
+  "./Command",
+], function (require, exports, Constants, Disposable, Command) {
+  "use strict";
+  var MenuViewModelBase = (function (_super) {
+    __extends(MenuViewModelBase, _super);
+    function MenuViewModelBase(lifetimeManager, element) {
+      var _this = this;
+      _super.call(this, lifetimeManager);
+      this.tooltip = "";
+      this.icon = null;
+      this._commands = ko.observableArray(null);
+      this.menu = ko.observable(null);
+      this.addMenuButton = function (command) {
+        var button = new Command.Button(_this._lifetimeManager, command);
+        var menuCommand = button.menuCommand();
+        _this._commands.push(menuCommand);
+        return menuCommand;
+      };
+      this.addDropdownButton = function (menuButton) {
+        $(menuButton.element).addClass(Constants.CSS.menuButtonClass);
+        $(_this.menu().element).addClass(Constants.CSS.dropdownMenuClass);
+        var menuButtonClicked = function (event) {
+          var handler = function (_event) {
+            $(menuButton.element).removeClass(Constants.CSS.hoveredClass);
+            _this.menu().removeEventListener("beforehide", handler);
+          };
+          _this.menu().addEventListener("beforehide", handler);
+          $(menuButton.element).addClass(Constants.CSS.hoveredClass);
+          _this.showMenu(menuButton.element);
+        };
+        menuButton._command.onclick(menuButtonClicked);
+        return menuButton;
+      };
+      element.setAttribute("data-win-control", "WinJS.UI.Menu");
+      WinJS.UI.processAll(element).then(function () {
+        _this.menu(element.winControl);
+      });
+    }
+    MenuViewModelBase.prototype.showMenu = function (anchor, type) {
+      if (type === void 0) {
+        type = "bottom";
+      }
+      this.menu().commands = this._commands();
+      this.menu().show(anchor, type);
+    };
+    return MenuViewModelBase;
+  })(Disposable.ChildDisposable);
+  exports.MenuViewModelBase = MenuViewModelBase;
+});
+//# sourceMappingURL=Menu.js.map

package/scripts/Framework/UI/PanelMessage.js

@@ -0,0 +1,25 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var PanelMessage = (function () {
+    function PanelMessage() {}
+    PanelMessage.showMessage = function (message) {
+      if ($(PanelMessage._messageSelector).length === 0) {
+        $(PanelMessage._panelSelector).prepend(PanelMessage._template);
+      }
+      $(PanelMessage._messageSelector).html(message);
+      $(PanelMessage._switchSelector).addClass(this._switchClass);
+    };
+    PanelMessage.removeMessage = function () {
+      $(PanelMessage._switchSelector).removeClass(this._switchClass);
+      $(PanelMessage._messageSelector).remove();
+    };
+    PanelMessage._panelSelector = ".rightSidePanel";
+    PanelMessage._messageSelector = ".adf-panelMessage";
+    PanelMessage._switchSelector = ".rightSidePanel .switch";
+    PanelMessage._switchClass = "adf-panelMessageSwitch";
+    PanelMessage._template = '<div class="adf-panelMessage"></div>';
+    return PanelMessage;
+  })();
+  exports.PanelMessage = PanelMessage;
+});
+//# sourceMappingURL=PanelMessage.js.map

package/scripts/Framework/UI/Refresh.js

@@ -0,0 +1,70 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define(["require", "exports", "../Shared/Disposable"], function (
+  require,
+  exports,
+  Disposable
+) {
+  "use strict";
+  var REFRESH_FREQUENCY = 5000;
+  var RefreshHandler = (function (_super) {
+    __extends(RefreshHandler, _super);
+    function RefreshHandler(lifetimeManager) {
+      var _this = this;
+      _super.call(this, lifetimeManager);
+      this.createElement = function (moment) {
+        var timestamp = ko.observable(moment);
+        var html = ko.pureComputed(function () {
+          return _this._template.replace(
+            /\{TIMESTAMP\}/,
+            timestamp().fromNow()
+          );
+        });
+        var element = {
+          html: html,
+          timestamp: timestamp,
+        };
+        _this._timestamps.push(timestamp);
+        return element;
+      };
+      this._template = "Last refreshed {TIMESTAMP}.";
+      this._timeout = null;
+      this._timestamps = [];
+      this._updateTimestamps = function () {
+        if (_this._timeout === null) {
+          return;
+        }
+        _this._timestamps.forEach(function (timestamp) {
+          if (timestamp()) {
+            timestamp.notifySubscribers();
+          }
+        });
+        _this._timeout = window.setTimeout(
+          _this._updateTimestamps,
+          REFRESH_FREQUENCY
+        );
+      };
+      this._timeout = window.setTimeout(
+        this._updateTimestamps,
+        REFRESH_FREQUENCY
+      );
+    }
+    RefreshHandler.prototype.dispose = function () {
+      _super.prototype.dispose.call(this);
+      var tmp = this._timeout;
+      this._timeout = null;
+      clearTimeout(tmp);
+    };
+    return RefreshHandler;
+  })(Disposable.ChildDisposable);
+  exports.RefreshHandler = RefreshHandler;
+});
+//# sourceMappingURL=Refresh.js.map

package/scripts/Framework/UI/Spinner.js

@@ -0,0 +1,61 @@
+define(["require", "exports", "../Util/Log"], function (require, exports, Log) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "Spinner",
+  });
+  var SpinnerInstance = (function () {
+    function SpinnerInstance(viewModel) {
+      this._viewModel = viewModel;
+      this._isOn = false;
+    }
+    SpinnerInstance.prototype.on = function () {
+      if (!this._isOn) {
+        this._isOn = true;
+        this._viewModel.instanceOn();
+      } else {
+        logger.logError("Spinner being toggled out of order");
+      }
+      return this;
+    };
+    SpinnerInstance.prototype.off = function () {
+      if (this._isOn) {
+        this._isOn = false;
+        this._viewModel.instanceOff();
+      } else {
+        logger.logError("Spinner being toggled out of order");
+      }
+      return this;
+    };
+    SpinnerInstance.prototype.promise = function (promise) {
+      var _this = this;
+      var final = function (args) {
+        _this.off();
+      };
+      promise.then(final, final);
+      return promise;
+    };
+    return SpinnerInstance;
+  })();
+  exports.SpinnerInstance = SpinnerInstance;
+  var SpinnerViewModel = (function () {
+    function SpinnerViewModel() {
+      this._spinners = 0;
+      this.spinner = ko.observable("");
+    }
+    SpinnerViewModel.prototype.instanceOff = function () {
+      this._spinners--;
+      if (this._spinners === 0) {
+        this.spinner("");
+      }
+    };
+    SpinnerViewModel.prototype.instanceOn = function () {
+      this._spinners++;
+    };
+    SpinnerViewModel.prototype.getInstance = function () {
+      return new SpinnerInstance(this);
+    };
+    return SpinnerViewModel;
+  })();
+  exports.SpinnerViewModel = SpinnerViewModel;
+});
+//# sourceMappingURL=Spinner.js.map