@angular-wave/angular.ts 0.0.51 → 0.0.53

package/src/directive/select/select.js

@@ -32,347 +32,343 @@ function setOptionSelectedStatus(optionEl, value) {
  * {@link ng.ngOptions ngOptions} select element.
  *
  */
-var SelectController = [
-  "$element",
-  "$scope",
-  function ($element, $scope) {
-    const self = this;
-    const optionsMap = new Map();
-
-    self.selectValueMap = {}; // Keys are the hashed values, values the original values
-
-    // If the ngModel doesn't get provided then provide a dummy noop version to prevent errors
-    self.ngModelCtrl = noopNgModelController;
-    self.multiple = false;
-
-    // The "unknown" option is one that is prepended to the list if the viewValue
-    // does not match any of the options. When it is rendered the value of the unknown
-    // option is '? XXX ?' where XXX is the hashKey of the value that is not known.
-    //
-    // Support: IE 9 only
-    // We can't just JQLite('<option>') since JQLite is not smart enough
-    // to create it in <select> and IE barfs otherwise.
-    self.unknownOption = JQLite(window.document.createElement("option"));
-
-    // The empty option is an option with the value '' that the application developer can
-    // provide inside the select. It is always selectable and indicates that a "null" selection has
-    // been made by the user.
-    // If the select has an empty option, and the model of the select is set to "undefined" or "null",
-    // the empty option is selected.
-    // If the model is set to a different unmatched value, the unknown option is rendered and
-    // selected, i.e both are present, because a "null" selection and an unknown value are different.
-    self.hasEmptyOption = false;
-    self.emptyOption = undefined;
-
-    self.renderUnknownOption = function (val) {
-      const unknownVal = self.generateUnknownOptionValue(val);
-      self.unknownOption.val(unknownVal);
-      $element.prepend(self.unknownOption);
-      setOptionSelectedStatus(self.unknownOption, true);
-      $element.val(unknownVal);
-    };
+SelectController.$inject = ["$element", "$scope"];
+function SelectController($element, $scope) {
+  const self = this;
+  const optionsMap = new Map();
+
+  self.selectValueMap = {}; // Keys are the hashed values, values the original values
+
+  // If the ngModel doesn't get provided then provide a dummy noop version to prevent errors
+  self.ngModelCtrl = noopNgModelController;
+  self.multiple = false;
+
+  // The "unknown" option is one that is prepended to the list if the viewValue
+  // does not match any of the options. When it is rendered the value of the unknown
+  // option is '? XXX ?' where XXX is the hashKey of the value that is not known.
+  //
+  // Support: IE 9 only
+  // We can't just JQLite('<option>') since JQLite is not smart enough
+  // to create it in <select> and IE barfs otherwise.
+  self.unknownOption = JQLite(window.document.createElement("option"));
+
+  // The empty option is an option with the value '' that the application developer can
+  // provide inside the select. It is always selectable and indicates that a "null" selection has
+  // been made by the user.
+  // If the select has an empty option, and the model of the select is set to "undefined" or "null",
+  // the empty option is selected.
+  // If the model is set to a different unmatched value, the unknown option is rendered and
+  // selected, i.e both are present, because a "null" selection and an unknown value are different.
+  self.hasEmptyOption = false;
+  self.emptyOption = undefined;
+
+  self.renderUnknownOption = function (val) {
+    const unknownVal = self.generateUnknownOptionValue(val);
+    self.unknownOption.val(unknownVal);
+    $element.prepend(self.unknownOption);
+    setOptionSelectedStatus(self.unknownOption, true);
+    $element.val(unknownVal);
+  };
 
-    self.updateUnknownOption = function (val) {
-      const unknownVal = self.generateUnknownOptionValue(val);
-      self.unknownOption.val(unknownVal);
-      setOptionSelectedStatus(self.unknownOption, true);
-      $element.val(unknownVal);
-    };
+  self.updateUnknownOption = function (val) {
+    const unknownVal = self.generateUnknownOptionValue(val);
+    self.unknownOption.val(unknownVal);
+    setOptionSelectedStatus(self.unknownOption, true);
+    $element.val(unknownVal);
+  };
 
-    self.generateUnknownOptionValue = function (val) {
-      return `? ${hashKey(val)} ?`;
-    };
+  self.generateUnknownOptionValue = function (val) {
+    return `? ${hashKey(val)} ?`;
+  };
 
-    self.removeUnknownOption = function () {
-      if (self.unknownOption.parent()) self.unknownOption.remove();
-    };
+  self.removeUnknownOption = function () {
+    if (self.unknownOption.parent()) self.unknownOption.remove();
+  };
 
-    self.selectEmptyOption = function () {
-      if (self.emptyOption) {
-        $element.val("");
-        setOptionSelectedStatus(self.emptyOption, true);
-      }
-    };
+  self.selectEmptyOption = function () {
+    if (self.emptyOption) {
+      $element.val("");
+      setOptionSelectedStatus(self.emptyOption, true);
+    }
+  };
 
-    self.unselectEmptyOption = function () {
-      if (self.hasEmptyOption) {
-        setOptionSelectedStatus(self.emptyOption, false);
-      }
-    };
+  self.unselectEmptyOption = function () {
+    if (self.hasEmptyOption) {
+      setOptionSelectedStatus(self.emptyOption, false);
+    }
+  };
 
-    $scope.$on("$destroy", () => {
-      // disable unknown option so that we don't do work when the whole select is being destroyed
-      self.renderUnknownOption = () => {};
-    });
+  $scope.$on("$destroy", () => {
+    // disable unknown option so that we don't do work when the whole select is being destroyed
+    self.renderUnknownOption = () => {};
+  });
 
-    // Read the value of the select control, the implementation of this changes depending
-    // upon whether the select can have multiple values and whether ngOptions is at work.
-    self.readValue = function readSingleValue() {
-      const val = $element.val();
-      // ngValue added option values are stored in the selectValueMap, normal interpolations are not
-      const realVal =
-        val in self.selectValueMap ? self.selectValueMap[val] : val;
+  // Read the value of the select control, the implementation of this changes depending
+  // upon whether the select can have multiple values and whether ngOptions is at work.
+  self.readValue = function readSingleValue() {
+    const val = $element.val();
+    // ngValue added option values are stored in the selectValueMap, normal interpolations are not
+    const realVal = val in self.selectValueMap ? self.selectValueMap[val] : val;
 
-      if (self.hasOption(realVal)) {
-        return realVal;
-      }
+    if (self.hasOption(realVal)) {
+      return realVal;
+    }
 
-      return null;
-    };
+    return null;
+  };
 
-    // Write the value to the select control, the implementation of this changes depending
-    // upon whether the select can have multiple values and whether ngOptions is at work.
-    self.writeValue = function writeSingleValue(value) {
-      // Make sure to remove the selected attribute from the previously selected option
-      // Otherwise, screen readers might get confused
-      const currentlySelectedOption =
-        $element[0].options[$element[0].selectedIndex];
-      if (currentlySelectedOption)
-        setOptionSelectedStatus(JQLite(currentlySelectedOption), false);
-
-      if (self.hasOption(value)) {
-        self.removeUnknownOption();
-
-        const hashedVal = hashKey(value);
-        $element.val(hashedVal in self.selectValueMap ? hashedVal : value);
-
-        // Set selected attribute and property on selected option for screen readers
-        const selectedOption = $element[0].options[$element[0].selectedIndex];
-        setOptionSelectedStatus(JQLite(selectedOption), true);
-      } else {
-        self.selectUnknownOrEmptyOption(value);
-      }
-    };
+  // Write the value to the select control, the implementation of this changes depending
+  // upon whether the select can have multiple values and whether ngOptions is at work.
+  self.writeValue = function writeSingleValue(value) {
+    // Make sure to remove the selected attribute from the previously selected option
+    // Otherwise, screen readers might get confused
+    const currentlySelectedOption =
+      $element[0].options[$element[0].selectedIndex];
+    if (currentlySelectedOption)
+      setOptionSelectedStatus(JQLite(currentlySelectedOption), false);
+
+    if (self.hasOption(value)) {
+      self.removeUnknownOption();
+
+      const hashedVal = hashKey(value);
+      $element.val(hashedVal in self.selectValueMap ? hashedVal : value);
+
+      // Set selected attribute and property on selected option for screen readers
+      const selectedOption = $element[0].options[$element[0].selectedIndex];
+      setOptionSelectedStatus(JQLite(selectedOption), true);
+    } else {
+      self.selectUnknownOrEmptyOption(value);
+    }
+  };
 
-    // Tell the select control that an option, with the given value, has been added
-    self.addOption = function (value, element) {
-      // Skip comment nodes, as they only pollute the `optionsMap`
-      if (element[0].nodeType === Node.COMMENT_NODE) return;
+  // Tell the select control that an option, with the given value, has been added
+  self.addOption = function (value, element) {
+    // Skip comment nodes, as they only pollute the `optionsMap`
+    if (element[0].nodeType === Node.COMMENT_NODE) return;
 
-      assertNotHasOwnProperty(value, '"option value"');
-      if (value === "") {
-        self.hasEmptyOption = true;
-        self.emptyOption = element;
-      }
-      const count = optionsMap.get(value) || 0;
-      optionsMap.set(value, count + 1);
-      // Only render at the end of a digest. This improves render performance when many options
-      // are added during a digest and ensures all relevant options are correctly marked as selected
-      scheduleRender();
-    };
+    assertNotHasOwnProperty(value, '"option value"');
+    if (value === "") {
+      self.hasEmptyOption = true;
+      self.emptyOption = element;
+    }
+    const count = optionsMap.get(value) || 0;
+    optionsMap.set(value, count + 1);
+    // Only render at the end of a digest. This improves render performance when many options
+    // are added during a digest and ensures all relevant options are correctly marked as selected
+    scheduleRender();
+  };
 
-    // Tell the select control that an option, with the given value, has been removed
-    self.removeOption = function (value) {
-      const count = optionsMap.get(value);
-      if (count) {
-        if (count === 1) {
-          optionsMap.delete(value);
-          if (value === "") {
-            self.hasEmptyOption = false;
-            self.emptyOption = undefined;
-          }
-        } else {
-          optionsMap.set(value, count - 1);
+  // Tell the select control that an option, with the given value, has been removed
+  self.removeOption = function (value) {
+    const count = optionsMap.get(value);
+    if (count) {
+      if (count === 1) {
+        optionsMap.delete(value);
+        if (value === "") {
+          self.hasEmptyOption = false;
+          self.emptyOption = undefined;
         }
+      } else {
+        optionsMap.set(value, count - 1);
       }
-    };
-
-    // Check whether the select control has an option matching the given value
-    self.hasOption = function (value) {
-      return !!optionsMap.get(value);
-    };
+    }
+  };
 
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$hasEmptyOption
-     *
-     * @description
-     *
-     * Returns `true` if the select element currently has an empty option
-     * element, i.e. an option that signifies that the select is empty / the selection is null.
-     *
-     */
-    self.$hasEmptyOption = function () {
-      return self.hasEmptyOption;
-    };
+  // Check whether the select control has an option matching the given value
+  self.hasOption = function (value) {
+    return !!optionsMap.get(value);
+  };
 
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$isUnknownOptionSelected
-     *
-     * @description
-     *
-     * Returns `true` if the select element's unknown option is selected. The unknown option is added
-     * and automatically selected whenever the select model doesn't match any option.
-     *
-     */
-    self.$isUnknownOptionSelected = function () {
-      // Presence of the unknown option means it is selected
-      return $element[0].options[0] === self.unknownOption[0];
-    };
+  /**
+   * @ngdoc method
+   * @name select.SelectController#$hasEmptyOption
+   *
+   * @description
+   *
+   * Returns `true` if the select element currently has an empty option
+   * element, i.e. an option that signifies that the select is empty / the selection is null.
+   *
+   */
+  self.$hasEmptyOption = function () {
+    return self.hasEmptyOption;
+  };
 
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$isEmptyOptionSelected
-     *
-     * @description
-     *
-     * Returns `true` if the select element has an empty option and this empty option is currently
-     * selected. Returns `false` if the select element has no empty option or it is not selected.
-     *
-     */
-    self.$isEmptyOptionSelected = function () {
-      return (
-        self.hasEmptyOption &&
-        $element[0].options[$element[0].selectedIndex] === self.emptyOption[0]
-      );
-    };
+  /**
+   * @ngdoc method
+   * @name select.SelectController#$isUnknownOptionSelected
+   *
+   * @description
+   *
+   * Returns `true` if the select element's unknown option is selected. The unknown option is added
+   * and automatically selected whenever the select model doesn't match any option.
+   *
+   */
+  self.$isUnknownOptionSelected = function () {
+    // Presence of the unknown option means it is selected
+    return $element[0].options[0] === self.unknownOption[0];
+  };
 
-    self.selectUnknownOrEmptyOption = function (value) {
-      if (value == null && self.emptyOption) {
-        self.removeUnknownOption();
-        self.selectEmptyOption();
-      } else if (self.unknownOption.parent().length) {
-        self.updateUnknownOption(value);
-      } else {
-        self.renderUnknownOption(value);
-      }
-    };
+  /**
+   * @ngdoc method
+   * @name select.SelectController#$isEmptyOptionSelected
+   *
+   * @description
+   *
+   * Returns `true` if the select element has an empty option and this empty option is currently
+   * selected. Returns `false` if the select element has no empty option or it is not selected.
+   *
+   */
+  self.$isEmptyOptionSelected = function () {
+    return (
+      self.hasEmptyOption &&
+      $element[0].options[$element[0].selectedIndex] === self.emptyOption[0]
+    );
+  };
 
-    let renderScheduled = false;
-    function scheduleRender() {
-      if (renderScheduled) return;
-      renderScheduled = true;
-      $scope.$$postDigest(() => {
-        renderScheduled = false;
-        self.ngModelCtrl.$render();
-      });
+  self.selectUnknownOrEmptyOption = function (value) {
+    if (value == null && self.emptyOption) {
+      self.removeUnknownOption();
+      self.selectEmptyOption();
+    } else if (self.unknownOption.parent().length) {
+      self.updateUnknownOption(value);
+    } else {
+      self.renderUnknownOption(value);
     }
+  };
 
-    let updateScheduled = false;
-    function scheduleViewValueUpdate(renderAfter) {
-      if (updateScheduled) return;
-
-      updateScheduled = true;
+  let renderScheduled = false;
+  function scheduleRender() {
+    if (renderScheduled) return;
+    renderScheduled = true;
+    $scope.$$postDigest(() => {
+      renderScheduled = false;
+      self.ngModelCtrl.$render();
+    });
+  }
 
-      $scope.$$postDigest(() => {
-        if ($scope.$$destroyed) return;
+  let updateScheduled = false;
+  function scheduleViewValueUpdate(renderAfter) {
+    if (updateScheduled) return;
 
-        updateScheduled = false;
-        self.ngModelCtrl.$setViewValue(self.readValue());
-        if (renderAfter) self.ngModelCtrl.$render();
-      });
-    }
+    updateScheduled = true;
 
-    self.registerOption = function (
-      optionScope,
-      optionElement,
-      optionAttrs,
-      interpolateValueFn,
-      interpolateTextFn,
-    ) {
-      let oldVal;
-      let hashedVal;
-      if (optionAttrs.$attr.ngValue) {
-        // The value attribute is set by ngValue
-
-        optionAttrs.$observe("value", (newVal) => {
-          let removal;
-          const previouslySelected = optionElement[0].selected;
-
-          if (isDefined(hashedVal)) {
-            self.removeOption(oldVal);
-            delete self.selectValueMap[hashedVal];
-            removal = true;
-          }
+    $scope.$$postDigest(() => {
+      if ($scope.$$destroyed) return;
 
-          hashedVal = hashKey(newVal);
-          oldVal = newVal;
-          self.selectValueMap[hashedVal] = newVal;
-          self.addOption(newVal, optionElement);
-          // Set the attribute directly instead of using optionAttrs.$set - this stops the observer
-          // from firing a second time. Other $observers on value will also get the result of the
-          // ngValue expression, not the hashed value
-          optionElement.attr("value", hashedVal);
-
-          if (removal && previouslySelected) {
-            scheduleViewValueUpdate();
-          }
-        });
-      } else if (interpolateValueFn) {
-        // The value attribute is interpolated
-        optionAttrs.$observe("value", (newVal) => {
-          // This method is overwritten in ngOptions and has side-effects!
-          self.readValue();
-
-          let removal;
-          const previouslySelected = optionElement[0].selected;
-
-          if (isDefined(oldVal)) {
-            self.removeOption(oldVal);
-            removal = true;
-          }
-          oldVal = newVal;
-          self.addOption(newVal, optionElement);
-
-          if (removal && previouslySelected) {
-            scheduleViewValueUpdate();
-          }
-        });
-      } else if (interpolateTextFn) {
-        // The text content is interpolated
-        optionScope.$watch(interpolateTextFn, (newVal, oldVal) => {
-          optionAttrs.$set("value", newVal);
-          const previouslySelected = optionElement[0].selected;
-          if (oldVal !== newVal) {
-            self.removeOption(oldVal);
-          }
-          self.addOption(newVal, optionElement);
+      updateScheduled = false;
+      self.ngModelCtrl.$setViewValue(self.readValue());
+      if (renderAfter) self.ngModelCtrl.$render();
+    });
+  }
 
-          if (oldVal && previouslySelected) {
-            scheduleViewValueUpdate();
-          }
-        });
-      } else {
-        // The value attribute is static
-        self.addOption(optionAttrs.value, optionElement);
-      }
+  self.registerOption = function (
+    optionScope,
+    optionElement,
+    optionAttrs,
+    interpolateValueFn,
+    interpolateTextFn,
+  ) {
+    let oldVal;
+    let hashedVal;
+    if (optionAttrs.$attr.ngValue) {
+      // The value attribute is set by ngValue
+
+      optionAttrs.$observe("value", (newVal) => {
+        let removal;
+        const previouslySelected = optionElement[0].selected;
+
+        if (isDefined(hashedVal)) {
+          self.removeOption(oldVal);
+          delete self.selectValueMap[hashedVal];
+          removal = true;
+        }
 
-      optionAttrs.$observe("disabled", (newVal) => {
-        // Since model updates will also select disabled options (like ngOptions),
-        // we only have to handle options becoming disabled, not enabled
+        hashedVal = hashKey(newVal);
+        oldVal = newVal;
+        self.selectValueMap[hashedVal] = newVal;
+        self.addOption(newVal, optionElement);
+        // Set the attribute directly instead of using optionAttrs.$set - this stops the observer
+        // from firing a second time. Other $observers on value will also get the result of the
+        // ngValue expression, not the hashed value
+        optionElement.attr("value", hashedVal);
+
+        if (removal && previouslySelected) {
+          scheduleViewValueUpdate();
+        }
+      });
+    } else if (interpolateValueFn) {
+      // The value attribute is interpolated
+      optionAttrs.$observe("value", (newVal) => {
+        // This method is overwritten in ngOptions and has side-effects!
+        self.readValue();
+
+        let removal;
+        const previouslySelected = optionElement[0].selected;
+
+        if (isDefined(oldVal)) {
+          self.removeOption(oldVal);
+          removal = true;
+        }
+        oldVal = newVal;
+        self.addOption(newVal, optionElement);
 
-        if (newVal === "true" || (newVal && optionElement[0].selected)) {
-          if (self.multiple) {
-            scheduleViewValueUpdate(true);
-          } else {
-            self.ngModelCtrl.$setViewValue(null);
-            self.ngModelCtrl.$render();
-          }
+        if (removal && previouslySelected) {
+          scheduleViewValueUpdate();
         }
       });
+    } else if (interpolateTextFn) {
+      // The text content is interpolated
+      optionScope.$watch(interpolateTextFn, (newVal, oldVal) => {
+        optionAttrs.$set("value", newVal);
+        const previouslySelected = optionElement[0].selected;
+        if (oldVal !== newVal) {
+          self.removeOption(oldVal);
+        }
+        self.addOption(newVal, optionElement);
 
-      optionElement.on("$destroy", () => {
-        const currentValue = self.readValue();
-        const removeValue = optionAttrs.value;
+        if (oldVal && previouslySelected) {
+          scheduleViewValueUpdate();
+        }
+      });
+    } else {
+      // The value attribute is static
+      self.addOption(optionAttrs.value, optionElement);
+    }
 
-        self.removeOption(removeValue);
-        scheduleRender();
+    optionAttrs.$observe("disabled", (newVal) => {
+      // Since model updates will also select disabled options (like ngOptions),
+      // we only have to handle options becoming disabled, not enabled
 
-        if (
-          (self.multiple &&
-            currentValue &&
-            currentValue.indexOf(removeValue) !== -1) ||
-          currentValue === removeValue
-        ) {
-          // When multiple (selected) options are destroyed at the same time, we don't want
-          // to run a model update for each of them. Instead, run a single update in the $$postDigest
+      if (newVal === "true" || (newVal && optionElement[0].selected)) {
+        if (self.multiple) {
           scheduleViewValueUpdate(true);
+        } else {
+          self.ngModelCtrl.$setViewValue(null);
+          self.ngModelCtrl.$render();
         }
-      });
-    };
-  },
-];
+      }
+    });
+
+    optionElement.on("$destroy", () => {
+      const currentValue = self.readValue();
+      const removeValue = optionAttrs.value;
+
+      self.removeOption(removeValue);
+      scheduleRender();
+
+      if (
+        (self.multiple &&
+          currentValue &&
+          currentValue.indexOf(removeValue) !== -1) ||
+        currentValue === removeValue
+      ) {
+        // When multiple (selected) options are destroyed at the same time, we don't want
+        // to run a model update for each of them. Instead, run a single update in the $$postDigest
+        scheduleViewValueUpdate(true);
+      }
+    });
+  };
+}
 
 /**
  * @ngdoc directive

package/src/public.js

@@ -185,7 +185,6 @@ export function publishExternalAPI() {
           $cacheFactory: CacheFactoryProvider,
           $controller: $ControllerProvider,
           $document: $DocumentProvider,
-          $$isDocumentHidden: $$IsDocumentHiddenProvider,
           $exceptionHandler: $ExceptionHandlerProvider,
           $filter: $FilterProvider,
           $interpolate: $InterpolateProvider,