@angular-wave/angular.ts 0.4.1 → 0.4.3

package/src/directive/input/input.spec.js

@@ -1,7 +1,6 @@
 import { Angular } from "../../loader";
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
 import { EMAIL_REGEXP, ISO_DATE_REGEXP, URL_REGEXP } from "./input";
-import { forEach } from "../../shared/utils";
 
 describe("input", () => {
   let $compile;
@@ -2157,197 +2156,194 @@ describe("input", () => {
         });
       });
 
-      forEach(
-        {
-          step: 'step="{{step}}"',
-          ngStep: 'ng-step="step"',
-        },
-        (attrHtml, attrName) => {
-          describe(attrName, () => {
-            it("should validate", () => {
-              scope.step = 10;
-              scope.value = 20;
-              const formElm = $compile(
-                `<form name="form"><input type="number" ng-model="value" name="alias" ${attrHtml} /></form>`,
-              )(scope);
-              inputElm = formElm.find("input");
-              scope.$digest();
-              expect(inputElm.val()).toBe("20");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(20);
-              expect(scope.form.alias.$error.step).toBeFalsy();
-
-              inputElm[0].value = "18";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(inputElm.val()).toBe("18");
-              expect(scope.value).toBeUndefined();
-              expect(scope.form.alias.$error.step).toBeTruthy();
-
-              inputElm[0].value = "10";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(inputElm.val()).toBe("10");
-              expect(scope.value).toBe(10);
-              expect(scope.form.alias.$error.step).toBeFalsy();
-
-              scope.$apply("value = 12");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(inputElm.val()).toBe("12");
-              expect(scope.value).toBe(12);
-              expect(scope.form.alias.$error.step).toBeTruthy();
-            });
-
-            it("should validate even if the step value changes on-the-fly", () => {
-              scope.step = 10;
-              const formElm = $compile(
-                `<form name="form"><input type="number" ng-model="value" name="alias" ${attrHtml} /></form>`,
-              )(scope);
-              inputElm = formElm.find("input");
-              inputElm[0].value = "10";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(10);
-
-              // Step changes, but value matches
-              scope.$apply("step = 5");
-              expect(inputElm.val()).toBe("10");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(10);
-              expect(scope.form.alias.$error.step).toBeFalsy();
-
-              // Step changes, value does not match
-              scope.$apply("step = 6");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(scope.value).toBeUndefined();
-              expect(inputElm.val()).toBe("10");
-              expect(scope.form.alias.$error.step).toBeTruthy();
-
-              // null = valid
-              scope.$apply("step = null");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(10);
-              expect(inputElm.val()).toBe("10");
-              expect(scope.form.alias.$error.step).toBeFalsy();
-
-              // Step val as string
-              scope.$apply('step = "7"');
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(scope.value).toBeUndefined();
-              expect(inputElm.val()).toBe("10");
-              expect(scope.form.alias.$error.step).toBeTruthy();
-
-              // unparsable string is ignored
-              scope.$apply('step = "abc"');
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(10);
-              expect(inputElm.val()).toBe("10");
-              expect(scope.form.alias.$error.step).toBeFalsy();
-            });
-
-            it('should use the correct "step base" when `[min]` is specified', () => {
-              scope.min = 5;
-              scope.step = 10;
-              scope.value = 10;
-              inputElm = $compile(
-                `<input type="number" ng-model="value" min="{{min}}" ${attrHtml} />`,
-              )(scope);
-              const ngModel = inputElm.controller("ngModel");
-              scope.$digest();
-              expect(inputElm.val()).toBe("10");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(ngModel.$error.step).toBe(true);
-              expect(scope.value).toBe(10); // an initially invalid value should not be changed
-
-              inputElm[0].value = "15";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(15);
-
-              scope.$apply("step = 3");
-              expect(inputElm.val()).toBe("15");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(ngModel.$error.step).toBe(true);
-              expect(scope.value).toBeUndefined();
-
-              inputElm[0].value = "8";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(8);
-
-              scope.$apply("min = 10; step = 20");
-              inputElm[0].value = "30";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm.val()).toBe("30");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(30);
-
-              scope.$apply("min = 5");
-              expect(inputElm.val()).toBe("30");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(ngModel.$error.step).toBe(true);
-              expect(scope.value).toBeUndefined();
-
-              scope.$apply("step = 0.00000001");
-              expect(inputElm.val()).toBe("30");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(30);
-
-              // 0.3 - 0.2 === 0.09999999999999998
-              scope.$apply("min = 0.2; step = (0.3 - 0.2)");
-              inputElm[0].value = "0.3";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm.val()).toBe("0.3");
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(ngModel.$error.step).toBe(true);
-              expect(scope.value).toBeUndefined();
-            });
-
-            it("should correctly validate even in cases where the JS floating point arithmetic fails", () => {
-              scope.step = 0.1;
-              inputElm = $compile(
-                `<input type="number" ng-model="value" ${attrHtml} />`,
-              )(scope);
-              const ngModel = inputElm.controller("ngModel");
-
-              expect(inputElm.val()).toBe("");
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBeUndefined();
-
-              inputElm[0].value = "0.3";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(0.3);
-
-              inputElm[0].value = "2.9999999999999996";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
-              expect(ngModel.$error.step).toBe(true);
-              expect(scope.value).toBeUndefined();
-
-              // 0.5 % 0.1 === 0.09999999999999998
-              inputElm[0].value = "0.5";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(0.5);
-
-              // // 3.5 % 0.1 === 0.09999999999999981
-              inputElm[0].value = "3.5";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(3.5);
-
-              // 1.16 % 0.01 === 0.009999999999999896
-              // 1.16 * 100  === 115.99999999999999
-              scope.step = 0.01;
-              inputElm[0].value = "1.16";
-              inputElm[0].dispatchEvent(new Event("change"));
-              expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
-              expect(scope.value).toBe(1.16);
-            });
+      Object.entries({
+        step: 'step="{{step}}"',
+        ngStep: 'ng-step="step"',
+      }).forEach(([attrName, attrHtml]) => {
+        describe(attrName, () => {
+          it("should validate", () => {
+            scope.step = 10;
+            scope.value = 20;
+            const formElm = $compile(
+              `<form name="form"><input type="number" ng-model="value" name="alias" ${attrHtml} /></form>`,
+            )(scope);
+            inputElm = formElm.find("input");
+            scope.$digest();
+            expect(inputElm.val()).toBe("20");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(20);
+            expect(scope.form.alias.$error.step).toBeFalsy();
+
+            inputElm[0].value = "18";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(inputElm.val()).toBe("18");
+            expect(scope.value).toBeUndefined();
+            expect(scope.form.alias.$error.step).toBeTruthy();
+
+            inputElm[0].value = "10";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(inputElm.val()).toBe("10");
+            expect(scope.value).toBe(10);
+            expect(scope.form.alias.$error.step).toBeFalsy();
+
+            scope.$apply("value = 12");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(inputElm.val()).toBe("12");
+            expect(scope.value).toBe(12);
+            expect(scope.form.alias.$error.step).toBeTruthy();
+          });
+
+          it("should validate even if the step value changes on-the-fly", () => {
+            scope.step = 10;
+            const formElm = $compile(
+              `<form name="form"><input type="number" ng-model="value" name="alias" ${attrHtml} /></form>`,
+            )(scope);
+            inputElm = formElm.find("input");
+            inputElm[0].value = "10";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(10);
+
+            // Step changes, but value matches
+            scope.$apply("step = 5");
+            expect(inputElm.val()).toBe("10");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(10);
+            expect(scope.form.alias.$error.step).toBeFalsy();
+
+            // Step changes, value does not match
+            scope.$apply("step = 6");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(scope.value).toBeUndefined();
+            expect(inputElm.val()).toBe("10");
+            expect(scope.form.alias.$error.step).toBeTruthy();
+
+            // null = valid
+            scope.$apply("step = null");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(10);
+            expect(inputElm.val()).toBe("10");
+            expect(scope.form.alias.$error.step).toBeFalsy();
+
+            // Step val as string
+            scope.$apply('step = "7"');
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(scope.value).toBeUndefined();
+            expect(inputElm.val()).toBe("10");
+            expect(scope.form.alias.$error.step).toBeTruthy();
+
+            // unparsable string is ignored
+            scope.$apply('step = "abc"');
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(10);
+            expect(inputElm.val()).toBe("10");
+            expect(scope.form.alias.$error.step).toBeFalsy();
+          });
+
+          it('should use the correct "step base" when `[min]` is specified', () => {
+            scope.min = 5;
+            scope.step = 10;
+            scope.value = 10;
+            inputElm = $compile(
+              `<input type="number" ng-model="value" min="{{min}}" ${attrHtml} />`,
+            )(scope);
+            const ngModel = inputElm.controller("ngModel");
+            scope.$digest();
+            expect(inputElm.val()).toBe("10");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(ngModel.$error.step).toBe(true);
+            expect(scope.value).toBe(10); // an initially invalid value should not be changed
+
+            inputElm[0].value = "15";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(15);
+
+            scope.$apply("step = 3");
+            expect(inputElm.val()).toBe("15");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(ngModel.$error.step).toBe(true);
+            expect(scope.value).toBeUndefined();
+
+            inputElm[0].value = "8";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(8);
+
+            scope.$apply("min = 10; step = 20");
+            inputElm[0].value = "30";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm.val()).toBe("30");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(30);
+
+            scope.$apply("min = 5");
+            expect(inputElm.val()).toBe("30");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(ngModel.$error.step).toBe(true);
+            expect(scope.value).toBeUndefined();
+
+            scope.$apply("step = 0.00000001");
+            expect(inputElm.val()).toBe("30");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(30);
+
+            // 0.3 - 0.2 === 0.09999999999999998
+            scope.$apply("min = 0.2; step = (0.3 - 0.2)");
+            inputElm[0].value = "0.3";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm.val()).toBe("0.3");
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(ngModel.$error.step).toBe(true);
+            expect(scope.value).toBeUndefined();
           });
-        },
-      );
+
+          it("should correctly validate even in cases where the JS floating point arithmetic fails", () => {
+            scope.step = 0.1;
+            inputElm = $compile(
+              `<input type="number" ng-model="value" ${attrHtml} />`,
+            )(scope);
+            const ngModel = inputElm.controller("ngModel");
+
+            expect(inputElm.val()).toBe("");
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBeUndefined();
+
+            inputElm[0].value = "0.3";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(0.3);
+
+            inputElm[0].value = "2.9999999999999996";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-invalid")).toBeTrue();
+            expect(ngModel.$error.step).toBe(true);
+            expect(scope.value).toBeUndefined();
+
+            // 0.5 % 0.1 === 0.09999999999999998
+            inputElm[0].value = "0.5";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(0.5);
+
+            // // 3.5 % 0.1 === 0.09999999999999981
+            inputElm[0].value = "3.5";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(3.5);
+
+            // 1.16 % 0.01 === 0.009999999999999896
+            // 1.16 * 100  === 115.99999999999999
+            scope.step = 0.01;
+            inputElm[0].value = "1.16";
+            inputElm[0].dispatchEvent(new Event("change"));
+            expect(inputElm[0].classList.contains("ng-valid")).toBeTrue();
+            expect(scope.value).toBe(1.16);
+          });
+        });
+      });
 
       describe("required", () => {
         it("should be valid even if value is 0", () => {

package/src/directive/list/list.js

@@ -1,4 +1,4 @@
-import { forEach, isUndefined, trim } from "../../shared/utils";
+import { isUndefined, trim } from "../../shared/utils";
 
 /**
  * @returns {import('../../types').Directive}
@@ -20,7 +20,7 @@ export function ngListDirective() {
         const list = [];
 
         if (viewValue) {
-          forEach(viewValue.split(separator), (value) => {
+          viewValue.split(separator).forEach((value) => {
             if (value) list.push(trimValues ? trim(value) : value);
           });
         }

package/src/directive/model/model.js

@@ -10,7 +10,6 @@ import {
 } from "../../shared/constants";
 import {
   minErr,
-  forEach,
   isNumber,
   isNumberNaN,
   isPromiseLike,
@@ -87,7 +86,7 @@ export class NgModelController {
    * @param {import('../../core/exception-handler').ErrorHandler} $exceptionHandler
    * @param {import('../../core/compile/attributes').Attributes} $attr
    * @param {import('../../shared/jqlite/jqlite').JQLite} $element
-   * @param {import("../../core/parser/parse").ParseService} $parse
+   * @param {import("../../core/parse/parse").ParseService} $parse
    * @param {*} $animate
    * @param {*} $timeout
    * @param {import("../../core/q/q").QPromise<any>} $q
@@ -147,7 +146,7 @@ export class NgModelController {
     this.$$parsedNgModel = $parse($attr["ngModel"]);
     this.$$parsedNgModelAssign = this.$$parsedNgModel.assign;
 
-    /** @type {import("../../core/parser/parse").CompiledExpression|((Scope) => any)} */
+    /** @type {import("../../core/parse/parse").CompiledExpression|((Scope) => any)} */
     this.$$ngModelGet = this.$$parsedNgModel;
     this.$$ngModelSet = this.$$parsedNgModelAssign;
     this.$$pendingDebounce = null;
@@ -597,10 +596,10 @@ export class NgModelController {
         setValidity(errorKey, null);
       } else {
         if (!that.$$parserValid) {
-          forEach(that.$validators, (v, name) => {
+          Object.keys(that.$validators).forEach((name) => {
             setValidity(name, null);
           });
-          forEach(that.$asyncValidators, (v, name) => {
+          Object.keys(that.$asyncValidators).forEach((name) => {
             setValidity(name, null);
           });
         }
@@ -614,13 +613,13 @@ export class NgModelController {
 
     function processSyncValidators() {
       let syncValidatorsValid = true;
-      forEach(that.$validators, (validator, name) => {
+      Object.entries(that.$validators).forEach(([name, validator]) => {
         const result = Boolean(validator(modelValue, viewValue));
         syncValidatorsValid = syncValidatorsValid && result;
         setValidity(name, result);
       });
       if (!syncValidatorsValid) {
-        forEach(that.$asyncValidators, (v, name) => {
+        Object.keys(that.$asyncValidators).forEach((name) => {
           setValidity(name, null);
         });
         return false;
@@ -631,7 +630,7 @@ export class NgModelController {
     function processAsyncValidators() {
       const validatorPromises = [];
       let allValid = true;
-      forEach(that.$asyncValidators, (validator, name) => {
+      Object.entries(that.$asyncValidators).forEach(([name, validator]) => {
         const promise = validator(modelValue, viewValue);
         if (!isPromiseLike(promise)) {
           throw ngModelMinErr(
@@ -776,17 +775,13 @@ export class NgModelController {
 
   $$writeModelToScope() {
     this.$$ngModelSet(this.$$scope, this.$modelValue);
-    forEach(
-      this.$viewChangeListeners,
-      function (listener) {
-        try {
-          listener();
-        } catch (e) {
-          this.$$exceptionHandler(e);
-        }
-      },
-      this,
-    );
+    Object.values(this.$viewChangeListeners).forEach((listener) => {
+      try {
+        listener();
+      } catch (e) {
+        this.$$exceptionHandler(e);
+      }
+    }, this);
   }
 
   /**

package/src/directive/model-options/model-options.js

@@ -1,4 +1,4 @@
-import { forEach, isDefined, trim } from "../../shared/utils";
+import { isDefined, trim } from "../../shared/utils";
 
 const DEFAULT_REGEXP = /(\s+|^)default(\s+|$)/;
 
@@ -70,33 +70,29 @@ class ModelOptions {
     options = Object.assign({}, options);
 
     // Inherit options from the parent if specified by the value `"$inherit"`
-    forEach(
-      options,
-      function (option, key) {
-        if (option === "$inherit") {
-          if (key === "*") {
-            inheritAll = true;
-          } else {
-            options[key] = this.$$options[key];
-            // `updateOn` is special so we must also inherit the `updateOnDefault` option
-            if (key === "updateOn") {
-              options.updateOnDefault = this.$$options.updateOnDefault;
-            }
+    Object.entries(options).forEach(([key, option]) => {
+      if (option === "$inherit") {
+        if (key === "*") {
+          inheritAll = true;
+        } else {
+          options[key] = this.$$options[key];
+          // `updateOn` is special so we must also inherit the `updateOnDefault` option
+          if (key === "updateOn") {
+            options.updateOnDefault = this.$$options.updateOnDefault;
           }
-        } else if (key === "updateOn") {
-          // If the `updateOn` property contains the `default` event then we have to remove
-          // it from the event list and set the `updateOnDefault` flag.
-          options.updateOnDefault = false;
-          options[key] = trim(
-            option.replace(DEFAULT_REGEXP, () => {
-              options.updateOnDefault = true;
-              return " ";
-            }),
-          );
         }
-      },
-      this,
-    );
+      } else if (key === "updateOn") {
+        // If the `updateOn` property contains the `default` event then we have to remove
+        // it from the event list and set the `updateOnDefault` flag.
+        options.updateOnDefault = false;
+        options[key] = trim(
+          /** @type {string} */ (option).replace(DEFAULT_REGEXP, () => {
+            options.updateOnDefault = true;
+            return " ";
+          }),
+        );
+      }
+    }, this);
 
     if (inheritAll) {
       // We have a property of the form: `"*": "$inherit"`

package/src/directive/options/options.js

@@ -1,7 +1,6 @@
 import { JQLite, removeElement, startingTag } from "../../shared/jqlite/jqlite";
 import {
   equals,
-  forEach,
   hashKey,
   includes,
   isArrayLike,
@@ -328,8 +327,7 @@ export const ngOptionsDirective = [
         selectCtrl.readValue = function readNgOptionsMultiple() {
           const selectedValues = selectElement.val() || [];
           const selections = [];
-
-          forEach(selectedValues, (value) => {
+          selectedValues.forEach((value) => {
             const option = options.selectValueMap[value];
             if (option && !option.disabled)
               selections.push(options.getViewValueFromOption(option));

package/src/directive/options/options.spec.js

@@ -2,7 +2,6 @@ import { createInjector } from "../../core/di/injector";
 import { JQLite, dealoc } from "../../shared/jqlite/jqlite";
 import { Angular } from "../../loader";
 import {
-  forEach,
   isBoolean,
   hashKey,
   equals,
@@ -232,7 +231,7 @@ describe("ngOptions", () => {
 
   function createSelect(attrs, blank, unknown) {
     let html = "<select";
-    forEach(attrs, (value, key) => {
+    Object.entries(attrs).forEach(([key, value]) => {
       if (isBoolean(value)) {
         if (value) html += ` ${key}`;
       } else {
@@ -2993,7 +2992,7 @@ describe("ngOptions", () => {
         const addSpiesOnProto =
           originalSelectedDescriptor && originalSelectedDescriptor.configurable;
 
-        forEach(options, (option, i) => {
+        Object.entries(options).forEach(([i, option]) => {
           const setSelected = function (value) {
             _selected[i] = value;
           };
@@ -3004,7 +3003,7 @@ describe("ngOptions", () => {
         });
 
         if (!addSpiesOnProto) {
-          forEach(options, (option, i) => {
+          Object.entries(options).forEach(([i, option]) => {
             Object.defineProperty(option, "selected", {
               get() {
                 return _selected[i];

package/src/directive/repeat/repeat.js

@@ -1,4 +1,4 @@
-import { forEach, minErr, hashKey, isArrayLike } from "../../shared/utils";
+import { minErr, hashKey, isArrayLike } from "../../shared/utils";
 import { getBlockNodes } from "../../shared/jqlite/jqlite";
 
 export const ngRepeatDirective = [
@@ -188,7 +188,7 @@ export const ngRepeatDirective = [
                 nextBlockOrder[index] = block;
               } else if (nextBlockMap[trackById]) {
                 // if collision detected. restore lastBlockMap and throw an error
-                forEach(nextBlockOrder, function (block) {
+                Object.values(nextBlockOrder).forEach((block) => {
                   if (block && block.scope) lastBlockMap[block.id] = block;
                 });
                 throw ngRepeatMinErr(