@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/directive/options/options.js

@@ -11,161 +11,6 @@ import {
 
 const ngOptionsMinErr = minErr("ngOptions");
 
-/**
- * @ngdoc directive
- * @name ngOptions
- * @restrict A
- *
- * @description
- *
- * The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
- * elements for the `<select>` element using the array or object obtained by evaluating the
- * `ngOptions` comprehension expression.
- *
- * In many cases, {@link ng.directive:ngRepeat ngRepeat} can be used on `<option>` elements instead of
- * `ngOptions` to achieve a similar result. However, `ngOptions` provides some benefits:
- * - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
- * comprehension expression
- * - reduced memory consumption by not creating a new scope for each repeated instance
- * - increased render speed by creating the options in a documentFragment instead of individually
- *
- * When an item in the `<select>` menu is selected, the array element or object property
- * represented by the selected option will be bound to the model identified by the `ngModel`
- * directive.
- *
- * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
- * be nested into the `<select>` element. This element will then represent the `null` or "not selected"
- * option. See example below for demonstration.
- *
- * ## Complex Models (objects or collections)
- *
- * By default, `ngModel` watches the model by reference, not value. This is important to know when
- * binding the select to a model that is an object or a collection.
- *
- * One issue occurs if you want to preselect an option. For example, if you set
- * the model to an object that is equal to an object in your collection, `ngOptions` won't be able to set the selection,
- * because the objects are not identical. So by default, you should always reference the item in your collection
- * for preselections, e.g.: `$scope.selected = $scope.collection[3]`.
- *
- * Another solution is to use a `track by` clause, because then `ngOptions` will track the identity
- * of the item not by reference, but by the result of the `track by` expression. For example, if your
- * collection items have an id property, you would `track by item.id`.
- *
- * A different issue with objects or collections is that ngModel won't detect if an object property or
- * a collection item changes. For that reason, `ngOptions` additionally watches the model using
- * `$watchCollection`, when the expression contains a `track by` clause or the the select has the `multiple` attribute.
- * This allows ngOptions to trigger a re-rendering of the options even if the actual object/collection
- * has not changed identity, but only a property on the object or an item in the collection changes.
- *
- * Note that `$watchCollection` does a shallow comparison of the properties of the object (or the items in the collection
- * if the model is an array). This means that changing a property deeper than the first level inside the
- * object/collection will not trigger a re-rendering.
- *
- * ## `select` **`as`**
- *
- * Using `select` **`as`** will bind the result of the `select` expression to the model, but
- * the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
- * or property name (for object data sources) of the value within the collection. If a **`track by`** expression
- * is used, the result of that expression will be set as the value of the `option` and `select` elements.
- *
- *
- * ### `select` **`as`** and **`track by`**
- *
- * <div class="alert alert-warning">
- * Be careful when using `select` **`as`** and **`track by`** in the same expression.
- * </div>
- *
- * Given this array of items on the $scope:
- *
- * ```js
- * $scope.items = [{
- *   id: 1,
- *   label: 'aLabel',
- *   subItem: { name: 'aSubItem' }
- * }, {
- *   id: 2,
- *   label: 'bLabel',
- *   subItem: { name: 'bSubItem' }
- * }];
- * ```
- *
- * This will work:
- *
- * ```html
- * <select ng-options="item as item.label for item in items track by item.id" ng-model="selected"></select>
- * ```
- * ```js
- * $scope.selected = $scope.items[0];
- * ```
- *
- * but this will not work:
- *
- * ```html
- * <select ng-options="item.subItem as item.label for item in items track by item.id" ng-model="selected"></select>
- * ```
- * ```js
- * $scope.selected = $scope.items[0].subItem;
- * ```
- *
- * In both examples, the **`track by`** expression is applied successfully to each `item` in the
- * `items` array. Because the selected option has been set programmatically in the controller, the
- * **`track by`** expression is also applied to the `ngModel` value. In the first example, the
- * `ngModel` value is `items[0]` and the **`track by`** expression evaluates to `items[0].id` with
- * no issue. In the second example, the `ngModel` value is `items[0].subItem` and the **`track by`**
- * expression evaluates to `items[0].subItem.id` (which is undefined). As a result, the model value
- * is not matched against any `<option>` and the `<select>` appears as having no selected value.
- *
- *
- * @param {string} ngModel Assignable AngularJS expression to data-bind to.
- * @param {comprehension_expression} ngOptions in one of the following forms:
- *
- *   * for array data sources:
- *     * `label` **`for`** `value` **`in`** `array`
- *     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
- *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
- *     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array`
- *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
- *     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
- *     * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
- *        (for including a filter with `track by`)
- *   * for object data sources:
- *     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
- *     * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
- *     * `label` **`disable when`** `disable` **`for (`**`key`**`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`group by`** `group`
- *         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`disable when`** `disable`
- *         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
- *
- * Where:
- *
- *   * `array` / `object`: an expression which evaluates to an array / object to iterate over.
- *   * `value`: local variable which will refer to each item in the `array` or each property value
- *      of `object` during iteration.
- *   * `key`: local variable which will refer to a property name in `object` during iteration.
- *   * `label`: The result of this expression will be the label for `<option>` element. The
- *     `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
- *   * `select`: The result of this expression will be bound to the model of the parent `<select>`
- *      element. If not specified, `select` expression will default to `value`.
- *   * `group`: The result of this expression will be used to group options using the `<optgroup>`
- *      DOM element.
- *   * `disable`: The result of this expression will be used to disable the rendered `<option>`
- *      element. Return `true` to disable.
- *   * `trackexpr`: Used when working with an array of objects. The result of this expression will be
- *      used to identify the objects in the array. The `trackexpr` will most likely refer to the
- *     `value` variable (e.g. `value.propertyName`). With this the selection is preserved
- *      even when the options are recreated (e.g. reloaded from the server).
- * @param {string=} name Property name of the form under which the control is published.
- * @param {string=} required The control is considered valid only if value is entered.
- * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
- *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
- *    `required` when you want to data-bind to the `required` attribute.
- * @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
- * {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
- *
- */
-
 const NG_OPTIONS_REGEXP =
   /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([$\w][$\w]*)|(?:\(\s*([$\w][$\w]*)\s*,\s*([$\w][$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/;
 // 1: value expression (valueFn)
@@ -618,7 +463,8 @@ export const ngOptionsDirective = [
 
               // Update the label on the group element
               // "null" is special cased because of Safari
-              groupElement.label =
+              /** @type {HTMLOptGroupElement} */
+              (groupElement).label =
                 option.group === null ? "null" : option.group;
 
               // Store it for use later

package/src/directive/options/options.md

@@ -0,0 +1,179 @@
+/\*\*
+
+-
+- The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
+- elements for the `<select>` element using the array or object obtained by evaluating the
+- `ngOptions` comprehension expression.
+-
+- In many cases, {@link ng.directive:ngRepeat ngRepeat} can be used on `<option>` elements instead of
+- `ngOptions` to achieve a similar result. However, `ngOptions` provides some benefits:
+- - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
+- comprehension expression
+- - reduced memory consumption by not creating a new scope for each repeated instance
+- - increased render speed by creating the options in a documentFragment instead of individually
+-
+- When an item in the `<select>` menu is selected, the array element or object property
+- represented by the selected option will be bound to the model identified by the `ngModel`
+- directive.
+-
+- Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
+- be nested into the `<select>` element. This element will then represent the `null` or "not selected"
+- option. See example below for demonstration.
+-
+- ## Complex Models (objects or collections)
+-
+- By default, `ngModel` watches the model by reference, not value. This is important to know when
+- binding the select to a model that is an object or a collection.
+-
+- One issue occurs if you want to preselect an option. For example, if you set
+- the model to an object that is equal to an object in your collection, `ngOptions` won't be able to set the selection,
+- because the objects are not identical. So by default, you should always reference the item in your collection
+- for preselections, e.g.: `$scope.selected = $scope.collection[3]`.
+-
+- Another solution is to use a `track by` clause, because then `ngOptions` will track the identity
+- of the item not by reference, but by the result of the `track by` expression. For example, if your
+- collection items have an id property, you would `track by item.id`.
+-
+- A different issue with objects or collections is that ngModel won't detect if an object property or
+- a collection item changes. For that reason, `ngOptions` additionally watches the model using
+- `$watchCollection`, when the expression contains a `track by` clause or the the select has the `multiple` attribute.
+- This allows ngOptions to trigger a re-rendering of the options even if the actual object/collection
+- has not changed identity, but only a property on the object or an item in the collection changes.
+-
+- Note that `$watchCollection` does a shallow comparison of the properties of the object (or the items in the collection
+- if the model is an array). This means that changing a property deeper than the first level inside the
+- object/collection will not trigger a re-rendering.
+-
+- ## `select` **`as`**
+-
+- Using `select` **`as`** will bind the result of the `select` expression to the model, but
+- the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
+- or property name (for object data sources) of the value within the collection. If a **`track by`** expression
+- is used, the result of that expression will be set as the value of the `option` and `select` elements.
+-
+-
+- ### `select` **`as`** and **`track by`**
+-
+- <div class="alert alert-warning">
+- Be careful when using `select` **`as`** and **`track by`** in the same expression.
+- </div>
+-
+- Given this array of items on the $scope:
+-
+- ```js
+
+  ```
+
+- $scope.items = [{
+- id: 1,
+- label: 'aLabel',
+- subItem: { name: 'aSubItem' }
+- }, {
+- id: 2,
+- label: 'bLabel',
+- subItem: { name: 'bSubItem' }
+- }];
+- ```
+
+  ```
+
+-
+- This will work:
+-
+- ```html
+
+  ```
+
+- <select ng-options="item as item.label for item in items track by item.id" ng-model="selected"></select>
+- ```
+
+  ```
+
+- ```js
+
+  ```
+
+- $scope.selected = $scope.items[0];
+- ```
+
+  ```
+
+-
+- but this will not work:
+-
+- ```html
+
+  ```
+
+- <select ng-options="item.subItem as item.label for item in items track by item.id" ng-model="selected"></select>
+- ```
+
+  ```
+
+- ```js
+
+  ```
+
+- $scope.selected = $scope.items[0].subItem;
+- ```
+
+  ```
+
+-
+- In both examples, the **`track by`** expression is applied successfully to each `item` in the
+- `items` array. Because the selected option has been set programmatically in the controller, the
+- **`track by`** expression is also applied to the `ngModel` value. In the first example, the
+- `ngModel` value is `items[0]` and the **`track by`** expression evaluates to `items[0].id` with
+- no issue. In the second example, the `ngModel` value is `items[0].subItem` and the **`track by`**
+- expression evaluates to `items[0].subItem.id` (which is undefined). As a result, the model value
+- is not matched against any `<option>` and the `<select>` appears as having no selected value.
+-
+-
+- @param {string} ngModel Assignable AngularJS expression to data-bind to.
+- @param {string} ngOptions in one of the following forms:
+-
+- - for array data sources:
+-     * `label` **`for`** `value` **`in`** `array`
+-     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
+-     * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
+-     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array`
+-     * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+-     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+-     * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
+-        (for including a filter with `track by`)
+- - for object data sources:
+-     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
+-     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
+-     * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
+-     * `label` **`disable when`** `disable` **`for (`**`key`**`,`** `value`**`) in`** `object`
+-     * `select` **`as`** `label` **`group by`** `group`
+-         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
+-     * `select` **`as`** `label` **`disable when`** `disable`
+-         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
+-
+- Where:
+-
+- - `array` / `object`: an expression which evaluates to an array / object to iterate over.
+- - `value`: local variable which will refer to each item in the `array` or each property value
+-      of `object` during iteration.
+- - `key`: local variable which will refer to a property name in `object` during iteration.
+- - `label`: The result of this expression will be the label for `<option>` element. The
+-     `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
+- - `select`: The result of this expression will be bound to the model of the parent `<select>`
+-      element. If not specified, `select` expression will default to `value`.
+- - `group`: The result of this expression will be used to group options using the `<optgroup>`
+-      DOM element.
+- - `disable`: The result of this expression will be used to disable the rendered `<option>`
+-      element. Return `true` to disable.
+- - `trackexpr`: Used when working with an array of objects. The result of this expression will be
+-      used to identify the objects in the array. The `trackexpr` will most likely refer to the
+-     `value` variable (e.g. `value.propertyName`). With this the selection is preserved
+-      even when the options are recreated (e.g. reloaded from the server).
+- @param {string=} name Property name of the form under which the control is published.
+- @param {string=} required The control is considered valid only if value is entered.
+- @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
+- the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
+- `required` when you want to data-bind to the `required` attribute.
+- @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
+- {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
+- \*/

package/src/directive/select/select.js

@@ -8,8 +8,6 @@ import {
   shallowCopy,
 } from "../../shared/utils";
 
-const noopNgModelController = { $setViewValue: () => {}, $render: () => {} };
-
 function setOptionSelectedStatus(optionEl, value) {
   optionEl[0].selected = value;
   /**
@@ -23,16 +21,17 @@ function setOptionSelectedStatus(optionEl, value) {
 }
 
 /**
- * @ngdoc type
- * @name  select.SelectController
- *
- * @description
  * The controller for the {@link ng.select select} directive. The controller exposes
  * a few utility methods that can be used to augment the behavior of a regular or an
  * {@link ng.ngOptions ngOptions} select element.
  *
  */
 SelectController.$inject = ["$element", "$scope"];
+/**
+ *
+ * @param {JQLite} $element
+ * @param {import('../../core/scope/scope').Scope} $scope
+ */
 function SelectController($element, $scope) {
   const self = this;
   const optionsMap = new Map();
@@ -40,7 +39,7 @@ function SelectController($element, $scope) {
   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.ngModelCtrl = {};
   self.multiple = false;
 
   // The "unknown" option is one that is prepended to the list if the viewValue
@@ -105,7 +104,7 @@ function SelectController($element, $scope) {
 
   // 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() {
+  self.readValue = function () {
     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;
@@ -371,80 +370,9 @@ function SelectController($element, $scope) {
 }
 
 /**
- * @ngdoc directive
- * @name select
- * @restrict E
- *
- * @description
- * HTML `select` element with AngularJS data-binding.
- *
- * The `select` directive is used together with {@link ngModel `ngModel`} to provide data-binding
- * between the scope and the `<select>` control (including setting default values).
- * It also handles dynamic `<option>` elements, which can be added using the {@link ngRepeat `ngRepeat}` or
- * {@link ngOptions `ngOptions`} directives.
- *
- * When an item in the `<select>` menu is selected, the value of the selected option will be bound
- * to the model identified by the `ngModel` directive. With static or repeated options, this is
- * the content of the `value` attribute or the textContent of the `<option>`, if the value attribute is missing.
- * Value and textContent can be interpolated.
- *
- * The {@link select.SelectController select controller} exposes utility functions that can be used
- * to manipulate the select's behavior.
- *
- * ## Matching model and option values
- *
- * In general, the match between the model and an option is evaluated by strictly comparing the model
- * value against the value of the available options.
- *
- * If you are setting the option value with the option's `value` attribute, or textContent, the
- * value will always be a `string` which means that the model value must also be a string.
- * Otherwise the `select` directive cannot match them correctly.
- *
- * To bind the model to a non-string value, you can use one of the following strategies:
- * - the {@link ng.ngOptions `ngOptions`} directive
- *   ({@link ng.select#using-select-with-ngoptions-and-setting-a-default-value})
- * - the {@link ng.ngValue `ngValue`} directive, which allows arbitrary expressions to be
- *   option values ({@link ng.select#using-ngvalue-to-bind-the-model-to-an-array-of-objects Example})
- * - model $parsers / $formatters to convert the string value
- *   ({@link ng.select#binding-select-to-a-non-string-value-via-ngmodel-parsing-formatting Example})
- *
- * If the viewValue of `ngModel` does not match any of the options, then the control
- * will automatically add an "unknown" option, which it then removes when the mismatch is resolved.
- *
- * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
- * be nested into the `<select>` element. This element will then represent the `null` or "not selected"
- * option. See example below for demonstration.
- *
- * ## Choosing between `ngRepeat` and `ngOptions`
- *
- * In many cases, `ngRepeat` can be used on `<option>` elements instead of {@link ng.directive:ngOptions
- * ngOptions} to achieve a similar result. However, `ngOptions` provides some benefits:
- * - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
- * comprehension expression
- * - reduced memory consumption by not creating a new scope for each repeated instance
- * - increased render speed by creating the options in a documentFragment instead of individually
- *
- * Specifically, select with repeated options slows down significantly starting at 2000 options in
- * Chrome and Internet Explorer / Edge.
- *
- *
- * @param {string} ngModel Assignable AngularJS expression to data-bind to.
- * @param {string=} name Property name of the form under which the control is published.
- * @param {string=} multiple Allows multiple options to be selected. The selected values will be
- *     bound to the model as an array.
- * @param {string=} required Sets `required` validation error key if the value is not entered.
- * @param {string=} ngRequired Adds required attribute and required validation constraint to
- * the element when the ngRequired expression evaluates to true. Use ngRequired instead of required
- * when you want to data-bind to the required attribute.
- * @param {string=} ngChange AngularJS expression to be executed when selected option(s) changes due to user
- *    interaction with the select element.
- * @param {string=} ngOptions sets the options that the select is populated with and defines what is
- * set on the model on selection. See {@link ngOptions `ngOptions`}.
- * @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
- * {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
- *
+ * @returns {import('../../types').Directive}
  */
-export const selectDirective = function () {
+export function selectDirective() {
   return {
     restrict: "E",
     require: ["select", "?ngModel"],
@@ -567,54 +495,55 @@ export const selectDirective = function () {
       selectCtrl.writeValue(ngModelCtrl.$viewValue);
     };
   }
-};
+}
 
 // The option directive is purely designed to communicate the existence (or lack of)
 // of dynamically created (and destroyed) option elements to their containing select
 // directive via its controller.
-export const optionDirective = [
-  "$interpolate",
-  function ($interpolate) {
-    return {
-      restrict: "E",
-      priority: 100,
-      compile(element, attr) {
-        let interpolateValueFn;
-        let interpolateTextFn;
-
-        if (isDefined(attr.ngValue)) {
-          // Will be handled by registerOption
-        } else if (isDefined(attr.value)) {
-          // If the value attribute is defined, check if it contains an interpolation
-          interpolateValueFn = $interpolate(attr.value, true);
-        } else {
-          // If the value attribute is not defined then we fall back to the
-          // text content of the option element, which may be interpolated
-          interpolateTextFn = $interpolate(element.text(), true);
-          if (!interpolateTextFn) {
-            attr.$set("value", element.text());
-          }
+/**
+ * @returns {import('../../types').Directive}
+ */
+optionDirective.$inject = ["$interpolate"];
+export function optionDirective($interpolate) {
+  return {
+    restrict: "E",
+    priority: 100,
+    compile(element, attr) {
+      let interpolateValueFn;
+      let interpolateTextFn;
+
+      if (isDefined(attr.ngValue)) {
+        // Will be handled by registerOption
+      } else if (isDefined(attr.value)) {
+        // If the value attribute is defined, check if it contains an interpolation
+        interpolateValueFn = $interpolate(attr.value, true);
+      } else {
+        // If the value attribute is not defined then we fall back to the
+        // text content of the option element, which may be interpolated
+        interpolateTextFn = $interpolate(element.text(), true);
+        if (!interpolateTextFn) {
+          attr.$set("value", element.text());
         }
+      }
 
-        return function (scope, element, attr) {
-          // This is an optimization over using ^^ since we don't want to have to search
-          // all the way to the root of the DOM for every single option element
-          const selectCtrlName = "$selectController";
-          const parent = element.parent();
-          const selectCtrl =
-            parent.data(selectCtrlName) || parent.parent().data(selectCtrlName); // in case we are in optgroup
-
-          if (selectCtrl) {
-            selectCtrl.registerOption(
-              scope,
-              element,
-              attr,
-              interpolateValueFn,
-              interpolateTextFn,
-            );
-          }
-        };
-      },
-    };
-  },
-];
+      return function (scope, element, attr) {
+        // This is an optimization over using ^^ since we don't want to have to search
+        // all the way to the root of the DOM for every single option element
+        const selectCtrlName = "$selectController";
+        const parent = element.parent();
+        const selectCtrl =
+          parent.data(selectCtrlName) || parent.parent().data(selectCtrlName); // in case we are in optgroup
+
+        if (selectCtrl) {
+          selectCtrl.registerOption(
+            scope,
+            element,
+            attr,
+            interpolateValueFn,
+            interpolateTextFn,
+          );
+        }
+      };
+    },
+  };
+}

package/src/directive/select/select.md

@@ -0,0 +1,74 @@
+/\*\*
+
+- @ngdoc directive
+- @name select
+- @restrict E
+-
+- @description
+- HTML `select` element with AngularJS data-binding.
+-
+- The `select` directive is used together with {@link ngModel `ngModel`} to provide data-binding
+- between the scope and the `<select>` control (including setting default values).
+- It also handles dynamic `<option>` elements, which can be added using the {@link ngRepeat `ngRepeat}` or
+- {@link ngOptions `ngOptions`} directives.
+-
+- When an item in the `<select>` menu is selected, the value of the selected option will be bound
+- to the model identified by the `ngModel` directive. With static or repeated options, this is
+- the content of the `value` attribute or the textContent of the `<option>`, if the value attribute is missing.
+- Value and textContent can be interpolated.
+-
+- The {@link select.SelectController select controller} exposes utility functions that can be used
+- to manipulate the select's behavior.
+-
+- ## Matching model and option values
+-
+- In general, the match between the model and an option is evaluated by strictly comparing the model
+- value against the value of the available options.
+-
+- If you are setting the option value with the option's `value` attribute, or textContent, the
+- value will always be a `string` which means that the model value must also be a string.
+- Otherwise the `select` directive cannot match them correctly.
+-
+- To bind the model to a non-string value, you can use one of the following strategies:
+- - the {@link ng.ngOptions `ngOptions`} directive
+- ({@link ng.select#using-select-with-ngoptions-and-setting-a-default-value})
+- - the {@link ng.ngValue `ngValue`} directive, which allows arbitrary expressions to be
+- option values ({@link ng.select#using-ngvalue-to-bind-the-model-to-an-array-of-objects Example})
+- - model $parsers / $formatters to convert the string value
+- ({@link ng.select#binding-select-to-a-non-string-value-via-ngmodel-parsing-formatting Example})
+-
+- If the viewValue of `ngModel` does not match any of the options, then the control
+- will automatically add an "unknown" option, which it then removes when the mismatch is resolved.
+-
+- Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
+- be nested into the `<select>` element. This element will then represent the `null` or "not selected"
+- option. See example below for demonstration.
+-
+- ## Choosing between `ngRepeat` and `ngOptions`
+-
+- In many cases, `ngRepeat` can be used on `<option>` elements instead of {@link ng.directive:ngOptions
+- ngOptions} to achieve a similar result. However, `ngOptions` provides some benefits:
+- - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
+- comprehension expression
+- - reduced memory consumption by not creating a new scope for each repeated instance
+- - increased render speed by creating the options in a documentFragment instead of individually
+-
+- Specifically, select with repeated options slows down significantly starting at 2000 options in
+- Chrome and Internet Explorer / Edge.
+-
+-
+- @param {string} ngModel Assignable AngularJS expression to data-bind to.
+- @param {string=} name Property name of the form under which the control is published.
+- @param {string=} multiple Allows multiple options to be selected. The selected values will be
+-     bound to the model as an array.
+- @param {string=} required Sets `required` validation error key if the value is not entered.
+- @param {string=} ngRequired Adds required attribute and required validation constraint to
+- the element when the ngRequired expression evaluates to true. Use ngRequired instead of required
+- when you want to data-bind to the required attribute.
+- @param {string=} ngChange AngularJS expression to be executed when selected option(s) changes due to user
+- interaction with the select element.
+- @param {string=} ngOptions sets the options that the select is populated with and defines what is
+- set on the model on selection. See {@link ngOptions `ngOptions`}.
+- @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
+- {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
+- \*/