@ms-atlas-module/datastudio-datafactory 0.1.36

package/bootstrapper/MonacoEditorKnockoutBinding.js

@@ -0,0 +1,67 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var MonacoEditorKnockoutBinding = (function () {
+    function MonacoEditorKnockoutBinding() {}
+    MonacoEditorKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var monacoElem = valueAccessor();
+      var container;
+      var updateValueComputed;
+      var isDisposed = false;
+      var createEditor = function () {
+        $(element).empty();
+        require(["vs/editor/editor.main"], function () {
+          if (isDisposed) {
+            return;
+          }
+          container = Monaco.Editor.create(element, {
+            value: monacoElem.monacoGeneralSettings.value(),
+            mode: monacoElem.monacoGeneralSettings.mode,
+            readOnly:
+              monacoElem.monacoGeneralSettings.readOnly !== undefined
+                ? monacoElem.monacoGeneralSettings.readOnly
+                : false,
+          });
+          container.addListener("change", function (val) {
+            monacoElem.monacoGeneralSettings.value(container.getValue());
+          });
+          updateValueComputed = ko.computed(function () {
+            var value = valueAccessor().monacoGeneralSettings.value();
+            if (container) {
+              container.setValue(value);
+            }
+          });
+        });
+      };
+      if (monacoElem.monacoContainerVisible()) {
+        createEditor();
+      } else {
+        var subscription_1 = monacoElem.monacoContainerVisible.subscribe(
+          function (isVisible) {
+            if (isVisible) {
+              subscription_1.dispose();
+              createEditor();
+            }
+          }
+        );
+      }
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+        isDisposed = true;
+        if (container) {
+          updateValueComputed.dispose();
+          container.dispose();
+        }
+      });
+      return { controlsDescendantBindings: true };
+    };
+    MonacoEditorKnockoutBinding.className = "monacoEditor";
+    return MonacoEditorKnockoutBinding;
+  })();
+  exports.MonacoEditorKnockoutBinding = MonacoEditorKnockoutBinding;
+});
+//# sourceMappingURL=MonacoEditorKnockoutBinding.js.map

package/bootstrapper/ParameterGroupsBinding.js

@@ -0,0 +1,289 @@
+define([
+  "require",
+  "exports",
+  "./FormFields",
+  "../scripts/Framework/Util/Log",
+  "../scripts/Framework/Shared/DataConstants",
+  "css!./CSS/ParameterGroups.css",
+  "text!./Templates/ParameterGroupsTemplate.html",
+], function (require, exports, FormFields_1, Log_1, DataConstants_1) {
+  "use strict";
+  var logger = Log_1.getLogger({
+    loggerName: "ParameterGroupsBinding",
+  });
+  var ParameterGroupsBinding = (function () {
+    function ParameterGroupsBinding() {}
+    ParameterGroupsBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var parameterViewModel = new ParameterGroupsViewModel(
+        valueAccessor().paramGroups,
+        valueAccessor().isSingleGroup,
+        valueAccessor().groupsTooltip,
+        valueAccessor().readOnly
+      );
+      element.innerHTML = ParameterGroupsBinding.template;
+      ko.applyBindingsToDescendants(parameterViewModel, element);
+      return { controlsDescendantBindings: true };
+    };
+    ParameterGroupsBinding.className = "parameterGroups";
+    ParameterGroupsBinding.template = require("text!./Templates/ParameterGroupsTemplate.html");
+    return ParameterGroupsBinding;
+  })();
+  exports.ParameterGroupsBinding = ParameterGroupsBinding;
+  var ParameterGroupsViewModel = (function () {
+    function ParameterGroupsViewModel(
+      paramGroups,
+      isSingleGroup,
+      groupsTooltip,
+      readOnly
+    ) {
+      var _this = this;
+      if (isSingleGroup === void 0) {
+        isSingleGroup = true;
+      }
+      if (groupsTooltip === void 0) {
+        groupsTooltip = "";
+      }
+      if (readOnly === void 0) {
+        readOnly = false;
+      }
+      this.paramNameHeading = ClientResources.paramNameHeading;
+      this.paramValueHeading = ClientResources.paramValueHeading;
+      this.groups = ko.observableArray();
+      this.readOnly = ko.observable();
+      this.customClass = "smallWidthField";
+      this.isSingleGroup = ko.observable(true);
+      this.groupsTooltip = "";
+      this.deleteClicked = function (selectedParam) {
+        ko.utils
+          .arrayFirst(_this.originalGroups(), function (group) {
+            return group.title === selectedParam.groupTitle;
+          })
+          .params.remove(function (param) {
+            return param.key === selectedParam.key;
+          });
+      };
+      this.addClicked = function () {
+        _this.newParamProperties.name.validationEnabled(true);
+        _this.isAddClicked(true);
+        var passedParam = {
+          key: ko.observable(_this.newParamProperties.name.value()),
+          value: ko.observable(_this.newParamProperties.value.value()),
+        };
+        if (passedParam.key() === "") {
+          return;
+        }
+        if (_this.isSingleGroup()) {
+          if (
+            !_this.isKeyAlreadyAdded(
+              _this.originalGroups()[0].params,
+              passedParam.key
+            )
+          ) {
+            _this.addPairAndResetFields(
+              _this.originalGroups()[0].params,
+              passedParam
+            );
+          }
+        } else {
+          var selectedGroup = ko.utils.arrayFirst(
+            _this.originalGroups(),
+            function (group) {
+              return group.title === _this.displayinGroups.value();
+            }
+          );
+          if (!_this.isKeyAlreadyAdded(selectedGroup.params, passedParam.key)) {
+            _this.addPairAndResetFields(selectedGroup.params, passedParam);
+          }
+        }
+        if (!_this.isSingleGroup()) {
+          _this.displayinGroups.value.subscribe(function (value) {
+            _this.isKeyUnique(true);
+          });
+        }
+        _this.newParamProperties.name.value.subscribe(function (value) {
+          _this.isKeyUnique(true);
+        });
+      };
+      this.readOnly(readOnly);
+      this.originalGroups = paramGroups;
+      this.isSingleGroup(isSingleGroup);
+      this.groupsTooltip = groupsTooltip;
+      paramGroups.subscribe(this.initializeNewGroups, this);
+      this.initializeNewGroups(paramGroups());
+      this.newParamProperties = {
+        name: new FormFields_1.ValidatedBoxViewModel({
+          label: this.paramNameHeading,
+          defaultValue: "",
+          validations: [
+            function (name) {
+              return _this.keyValidation(name);
+            },
+          ],
+        }),
+        value: new FormFields_1.ValidatedBoxViewModel({
+          label: this.paramValueHeading,
+          defaultValue: "",
+        }),
+      };
+      this.isKeyUnique = ko.observable(true);
+      this.isAddClicked = ko.observable(false);
+      var existingGroups = ko.observableArray([]);
+      this.groups().forEach(function (gr) {
+        existingGroups.push({ value: gr.title, displayText: gr.title });
+      });
+      this.displayinGroups = new FormFields_1.ValidatedSelectBoxViewModel(
+        existingGroups,
+        { label: "Groups", infoBalloon: this.groupsTooltip }
+      );
+    }
+    ParameterGroupsViewModel.prototype.isKeyAlreadyAdded = function (
+      group,
+      key
+    ) {
+      var keyValue = key();
+      var groupCopy = group();
+      for (var i = 0; i < groupCopy.length; i++) {
+        if (groupCopy[i].key() === keyValue) {
+          this.isKeyUnique(false);
+          return true;
+        }
+      }
+      return false;
+    };
+    ParameterGroupsViewModel.prototype.addPairAndResetFields = function (
+      group,
+      newParam
+    ) {
+      group.push(newParam);
+      this.isAddClicked(false);
+      this.newParamProperties.name.value("");
+      this.newParamProperties.value.value("");
+    };
+    ParameterGroupsViewModel.prototype.initializeNewGroups = function (
+      updatedList
+    ) {
+      var _this = this;
+      updatedList.forEach(function (group) {
+        if (
+          !_this.groups().some(function (groupWithForm) {
+            return groupWithForm.title === group.title;
+          })
+        ) {
+          _this.addGroup(group);
+        }
+      });
+    };
+    ParameterGroupsViewModel.prototype.addGroup = function (group) {
+      var _this = this;
+      var validatedParams = ko.observableArray();
+      group.params().forEach(function (param) {
+        _this.addParam(param, validatedParams, group.title);
+      });
+      this.groups.push({ title: group.title, params: validatedParams });
+      group.params.subscribe(
+        function (arrayUpdates) {
+          var existingGroup;
+          _this.groups().forEach(function (groupWithForm) {
+            if (group.title === groupWithForm.title) {
+              existingGroup = groupWithForm;
+              return;
+            }
+          });
+          if (existingGroup) {
+            arrayUpdates.forEach(function (arrayChange) {
+              if (arrayChange.moved || arrayChange.moved === 0) {
+                logger.logError("Group parameters should not be moved");
+              } else if (
+                arrayChange.status ===
+                DataConstants_1.ObsArrayChangeStatus.added
+              ) {
+                _this.addParam(
+                  arrayChange.value,
+                  existingGroup.params,
+                  existingGroup.title
+                );
+              } else if (
+                arrayChange.status ===
+                DataConstants_1.ObsArrayChangeStatus.deleted
+              ) {
+                existingGroup.params().forEach(function (validatedParam) {
+                  if (validatedParam.key === arrayChange.value.key) {
+                    existingGroup.params.remove(validatedParam);
+                    return;
+                  }
+                });
+              } else {
+                logger.logError(
+                  "Unrecognized ko arrayChange status: " + arrayChange.status
+                );
+              }
+            });
+          } else {
+            logger.logError(
+              "Group with title " +
+                group.title +
+                " was expected in paramter binding groups but was not found."
+            );
+          }
+        },
+        null,
+        "arrayChange"
+      );
+    };
+    ParameterGroupsViewModel.prototype.addParam = function (
+      param,
+      destination,
+      groupTitle
+    ) {
+      var newParam = {
+        key: param.key,
+        value: param.value,
+        keyForm: new FormFields_1.ValidatedBoxViewModel({
+          label: "",
+          defaultValue: param.key(),
+        }),
+        valueForm: new FormFields_1.ValidatedBoxViewModel({
+          label: "",
+          defaultValue: param.value(),
+        }),
+        groupTitle: groupTitle,
+      };
+      newParam.keyForm.value.subscribe(param.key);
+      newParam.valueForm.value.subscribe(param.value);
+      destination.push(newParam);
+    };
+    ParameterGroupsViewModel.prototype.keyValidation = function (name) {
+      if (name) {
+        if (this.isKeyUnique()) {
+          return Q({
+            valid: true,
+            message: "",
+          });
+        } else {
+          return Q({
+            valid: false,
+            message: ClientResources.ValidationNameAlreadyTaken,
+          });
+        }
+      } else if (this.isAddClicked()) {
+        return Q({
+          valid: false,
+          message: ClientResources.ValidationFieldIsRequired,
+        });
+      } else {
+        return Q({
+          valid: true,
+          message: "",
+        });
+      }
+    };
+    return ParameterGroupsViewModel;
+  })();
+});
+//# sourceMappingURL=ParameterGroupsBinding.js.map

package/bootstrapper/PivotKnockoutBinding.js

@@ -0,0 +1,61 @@
+define([
+  "require",
+  "exports",
+  "css!./CSS/Pivot.css",
+  "text!./Templates/PivotTemplate.html",
+], function (require, exports) {
+  "use strict";
+  var PivotViewModel = (function () {
+    function PivotViewModel(pivotItems, initialSelection) {
+      this.displayPivotItems = pivotItems.map(function (pivotItem, index) {
+        return {
+          header: pivotItem.header,
+          viewModel: pivotItem.viewModel,
+          template: pivotItem.template,
+          selected: ko.observable(index === initialSelection ? true : false),
+        };
+      });
+      this.existingSelection = ko.observable(
+        this.displayPivotItems[initialSelection]
+      );
+    }
+    return PivotViewModel;
+  })();
+  var PivotKnockoutBinding = (function () {
+    function PivotKnockoutBinding() {}
+    PivotKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var initialSelection = valueAccessor().initialSelection
+        ? valueAccessor().initialSelection
+        : 0;
+      var pivotViewModel = new PivotViewModel(
+        valueAccessor().pivotItems,
+        initialSelection
+      );
+      var selectionChangedCallback = valueAccessor().onSelectionChanged;
+      pivotViewModel.handlePivotItemSelection = function (selectedItem) {
+        if (selectedItem !== pivotViewModel.existingSelection()) {
+          pivotViewModel.existingSelection().selected(false);
+          selectedItem.selected(true);
+          pivotViewModel.existingSelection(selectedItem);
+          if (selectionChangedCallback) {
+            selectionChangedCallback(selectedItem);
+          }
+        }
+      };
+      element.innerHTML = PivotKnockoutBinding.template;
+      ko.applyBindingsToDescendants(pivotViewModel, element);
+      return { controlsDescendantBindings: true };
+    };
+    PivotKnockoutBinding.className = "pivot";
+    PivotKnockoutBinding.template = require("text!./Templates/PivotTemplate.html");
+    return PivotKnockoutBinding;
+  })();
+  exports.PivotKnockoutBinding = PivotKnockoutBinding;
+});
+//# sourceMappingURL=PivotKnockoutBinding.js.map