@angular-wave/angular.ts 0.4.1 → 0.4.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",
@@ -26,13 +26,13 @@
     "generate-docs": "node_modules/.bin/typedoc"
   },
   "devDependencies": {
-    "@playwright/test": "^1.44.0",
+    "@playwright/test": "latest",
     "@rollup/plugin-commonjs": "latest",
     "@rollup/plugin-node-resolve": "latest",
-    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-terser": "latest",
     "@types/jasmine": "latest",
     "@types/node": "latest",
-    "docdash": "^2.0.2",
+    "docdash": "latest",
     "eslint": "latest",
     "eslint-config-airbnb-base": "latest",
     "eslint-config-prettier": "latest",
@@ -40,12 +40,12 @@
     "eslint-plugin-promise": "latest",
     "express": "latest",
     "jasmine-core": "latest",
-    "jsdoc": "^4.0.3",
+    "jsdoc": "latest",
     "npm-run-all": "latest",
-    "playwright": "^1.44.0",
+    "playwright": "latest",
     "prettier": "latest",
     "rollup": "latest",
-    "rollup-plugin-version-injector": "^1.3.3",
+    "rollup-plugin-version-injector": "latest",
     "sinon": "latest",
     "typedoc": "latest",
     "typescript": "latest",

package/src/angular.spec.js

@@ -17,7 +17,6 @@ import {
   isArrayLike,
   encodeUriSegment,
   encodeUriQuery,
-  forEach,
   toJson,
   fromJson,
   nextUid,
@@ -1257,268 +1256,6 @@ describe("angular", () => {
     });
   });
 
-  describe("forEach", () => {
-    it("should iterate over *own* object properties", () => {
-      function MyObj() {
-        this.bar = "barVal";
-        this.baz = "bazVal";
-      }
-      MyObj.prototype.foo = "fooVal";
-
-      const obj = new MyObj();
-      const log = [];
-
-      forEach(obj, (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-
-      expect(log).toEqual(["bar:barVal", "baz:bazVal"]);
-    });
-
-    it("should not break if obj is an array we override hasOwnProperty", () => {
-      const obj = [];
-      obj[0] = 1;
-      obj[1] = 2;
-      obj.hasOwnProperty = null;
-      const log = [];
-      forEach(obj, (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-      expect(log).toEqual(["0:1", "1:2"]);
-    });
-
-    it("should handle JQLite and jQuery objects like arrays", () => {
-      let jqObject = JQLite("<p><span>s1</span><span>s2</span></p>").find(
-        "span",
-      );
-      let log = [];
-
-      forEach(jqObject, (value, key) => {
-        log.push(`${key}:${value.innerHTML}`);
-      });
-      expect(log).toEqual(["0:s1", "1:s2"]);
-
-      log = [];
-      jqObject = JQLite("<pane></pane>");
-      forEach(jqObject.children(), (value, key) => {
-        log.push(`${key}:${value.innerHTML}`);
-      });
-      expect(log).toEqual([]);
-    });
-
-    it("should handle NodeList objects like arrays", () => {
-      const nodeList = JQLite(
-        "<p><span>a</span><span>b</span><span>c</span></p>",
-      )[0].childNodes;
-      const log = [];
-
-      forEach(nodeList, (value, key) => {
-        log.push(`${key}:${value.innerHTML}`);
-      });
-      expect(log).toEqual(["0:a", "1:b", "2:c"]);
-    });
-
-    it("should handle HTMLCollection objects like arrays", () => {
-      document.getElementById("dummy").innerHTML =
-        "<p>" +
-        "<a name='x'>a</a>" +
-        "<a name='y'>b</a>" +
-        "<a name='x'>c</a>" +
-        "</p>";
-
-      const htmlCollection = document.getElementsByName("x");
-      const log = [];
-
-      forEach(htmlCollection, (value, key) => {
-        log.push(`${key}:${value.innerHTML}`);
-      });
-      expect(log).toEqual(["0:a", "1:c"]);
-    });
-
-    it("should handle arguments objects like arrays", () => {
-      let args;
-      const log = [];
-
-      (function () {
-        args = arguments;
-      })("a", "b", "c");
-
-      forEach(args, (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-      expect(log).toEqual(["0:a", "1:b", "2:c"]);
-    });
-
-    it("should handle string values like arrays", () => {
-      const log = [];
-
-      forEach("bar", (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-      expect(log).toEqual(["0:b", "1:a", "2:r"]);
-    });
-
-    it("should handle objects with length property as objects", () => {
-      const obj = {
-        foo: "bar",
-        length: 2,
-      };
-      const log = [];
-
-      forEach(obj, (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-      expect(log).toEqual(["foo:bar", "length:2"]);
-    });
-
-    it("should handle objects of custom types with length property as objects", () => {
-      function CustomType() {
-        this.length = 2;
-        this.foo = "bar";
-      }
-
-      const obj = new CustomType();
-      const log = [];
-
-      forEach(obj, (value, key) => {
-        log.push(`${key}:${value}`);
-      });
-      expect(log).toEqual(["length:2", "foo:bar"]);
-    });
-
-    it("should not invoke the iterator for indexed properties which are not present in the collection", () => {
-      const log = [];
-      const collection = [];
-      collection[5] = "SPARSE";
-      forEach(collection, (item, index) => {
-        log.push(item + index);
-      });
-      expect(log.length).toBe(1);
-      expect(log[0]).toBe("SPARSE5");
-    });
-
-    it("should safely iterate through objects with no prototype parent", () => {
-      const obj = extend(Object.create(null), {
-        a: 1,
-        b: 2,
-        c: 3,
-      });
-      const log = [];
-      const self = {};
-      forEach(
-        obj,
-        function (val, key, collection) {
-          expect(this).toBe(self);
-          expect(collection).toBe(obj);
-          log.push(`${key}=${val}`);
-        },
-        self,
-      );
-      expect(log.length).toBe(3);
-      expect(log).toEqual(["a=1", "b=2", "c=3"]);
-    });
-
-    it("should safely iterate through objects which shadow Object.prototype.hasOwnProperty", () => {
-      const obj = {
-        hasOwnProperty: true,
-        a: 1,
-        b: 2,
-        c: 3,
-      };
-      const log = [];
-      const self = {};
-      forEach(
-        obj,
-        function (val, key, collection) {
-          expect(this).toBe(self);
-          expect(collection).toBe(obj);
-          log.push(`${key}=${val}`);
-        },
-        self,
-      );
-      expect(log.length).toBe(4);
-      expect(log).toEqual(["hasOwnProperty=true", "a=1", "b=2", "c=3"]);
-    });
-
-    describe("ES spec api compliance", () => {
-      function testForEachSpec(expectedSize, collection) {
-        const that = {};
-
-        forEach(
-          collection,
-          function (value, key, collectionArg) {
-            expect(collectionArg).toBe(collection);
-            expect(collectionArg[key]).toBe(value);
-
-            expect(this).toBe(that);
-
-            expectedSize--;
-          },
-          that,
-        );
-
-        expect(expectedSize).toBe(0);
-      }
-
-      it("should follow the ES spec when called with array", () => {
-        testForEachSpec(2, [1, 2]);
-      });
-
-      it("should follow the ES spec when called with arguments", () => {
-        testForEachSpec(
-          2,
-          (function () {
-            return arguments;
-          })(1, 2),
-        );
-      });
-
-      it("should follow the ES spec when called with string", () => {
-        testForEachSpec(2, "12");
-      });
-
-      it("should follow the ES spec when called with jQuery/shared/jqlite/jqlite", () => {
-        testForEachSpec(2, JQLite("<span>a</span><span>b</span>"));
-      });
-
-      it("should follow the ES spec when called with childNodes NodeList", () => {
-        testForEachSpec(
-          2,
-          JQLite("<p><span>a</span><span>b</span></p>")[0].childNodes,
-        );
-      });
-
-      it("should follow the ES spec when called with getElementsByTagName HTMLCollection", () => {
-        testForEachSpec(
-          2,
-          JQLite("<p><span>a</span><span>b</span></p>")[0].getElementsByTagName(
-            "*",
-          ),
-        );
-      });
-
-      it("should follow the ES spec when called with querySelectorAll HTMLCollection", () => {
-        testForEachSpec(
-          2,
-          JQLite("<p><span>a</span><span>b</span></p>")[0].querySelectorAll(
-            "*",
-          ),
-        );
-      });
-
-      it("should follow the ES spec when called with JSON", () => {
-        testForEachSpec(2, { a: 1, b: 2 });
-      });
-
-      it("should follow the ES spec when called with function", () => {
-        function f() {}
-        f.a = 1;
-        f.b = 2;
-        testForEachSpec(2, f);
-      });
-    });
-  });
-
   describe("encodeUriSegment", () => {
     it("should correctly encode uri segment and not encode chars defined as pchar set in rfc3986", () => {
       // don't encode alphanum
@@ -1993,7 +1730,7 @@ describe("angular", () => {
         body,
         element,
       ];
-      forEach(tests, (value, idx) => {
+      Object.entries(tests).forEach(([idx, value]) => {
         const result = isElement(value);
         expect(typeof result).toEqual("boolean");
         expect(result).toEqual(expected[idx]);

package/src/animations/animate-css-driver.js

@@ -1,5 +1,5 @@
 import { JQLite } from "../shared/jqlite/jqlite";
-import { forEach, isString } from "../shared/utils";
+import { isString } from "../shared/utils";
 import { concatWithSpace, getDomNode } from "./shared";
 
 const NG_ANIMATE_SHIM_CLASS_NAME = "ng-animate-shim";
@@ -211,7 +211,7 @@ export function AnimateCssDriverProvider($$animationProvider) {
               animationRunners.push(toAnimation.start());
             }
 
-            forEach(anchorAnimations, (animation) => {
+            anchorAnimations.forEach((animation) => {
               animationRunners.push(animation.start());
             });
 

package/src/animations/animate-css.js

@@ -1,4 +1,4 @@
-import { forEach, isDefined } from "../shared/utils";
+import { isDefined } from "../shared/utils";
 import {
   TRANSITION_DURATION_PROP,
   TRANSITION_DELAY_PROP,
@@ -67,7 +67,7 @@ function getCssDelayStyle(delay, isKeyframeAnimation) {
 function computeCssStyles(element, properties) {
   const styles = Object.create(null);
   const detectedStyles = window.getComputedStyle(element) || {};
-  forEach(properties, (formalStyleName, actualStyleName) => {
+  Object.entries(properties).forEach(([actualStyleName, formalStyleName]) => {
     let val = detectedStyles[formalStyleName];
     if (val) {
       const c = val.charAt(0);
@@ -92,8 +92,7 @@ function computeCssStyles(element, properties) {
 
 function parseMaxTime(str) {
   let maxValue = 0;
-  const values = str.split(/\s*,\s*/);
-  forEach(values, (value) => {
+  str.split(/\s*,\s*/).forEach((value) => {
     // it's always safe to consider only second values and omit `ms` values since
     // getComputedStyle will always handle the conversion for us
     if (value.charAt(value.length - 1) === "s") {
@@ -130,7 +129,7 @@ function getCssTransitionDurationStyle(duration, applyOnlyDuration) {
 // is to be removed at the end of the animation). If we had a simple
 // "OR" statement then it would not be enough to catch that.
 function registerRestorableStyles(backup, node, properties) {
-  forEach(properties, (prop) => {
+  properties.forEach((prop) => {
     backup[prop] = isDefined(backup[prop])
       ? backup[prop]
       : node.style.getPropertyValue(prop);
@@ -599,7 +598,7 @@ export function AnimateCssProvider() {
           blockKeyframeAnimations(node, false);
           blockTransitions(node, false);
 
-          forEach(temporaryStyles, (entry) => {
+          temporaryStyles.forEach((entry) => {
             // There is only one way to remove inline style properties entirely from elements.
             // By using `removeProperty` this works, but we need to convert camel-cased CSS
             // styles down to hyphenated values.
@@ -610,7 +609,7 @@ export function AnimateCssProvider() {
           applyAnimationStyles(element, options);
 
           if (Object.keys(restoreStyles).length) {
-            forEach(restoreStyles, (value, prop) => {
+            Object.entries(restoreStyles).forEach(([prop, value]) => {
               if (value) {
                 node.style.setProperty(prop, value);
               } else {
@@ -775,7 +774,7 @@ export function AnimateCssProvider() {
 
             applyBlocking(false);
 
-            forEach(temporaryStyles, (entry) => {
+            temporaryStyles.forEach((entry) => {
               const key = entry[0];
               const value = entry[1];
               node.style[key] = value;

package/src/animations/animate-js-driver.js

@@ -1,5 +1,3 @@
-import { forEach } from "../shared/utils";
-
 AnimateJsDriverProvider.$inject = ["$$animationProvider"];
 export function AnimateJsDriverProvider($$animationProvider) {
   $$animationProvider.drivers.push("$$animateJsDriver");
@@ -36,7 +34,7 @@ export function AnimateJsDriverProvider($$animationProvider) {
 
               function endFnFactory() {
                 return function () {
-                  forEach(animationRunners, (runner) => {
+                  animationRunners.forEach((runner) => {
                     // at this point we cannot cancel animations for groups just yet. 1.5+
                     runner.end();
                   });

package/src/animations/animate-js.js

@@ -1,4 +1,4 @@
-import { forEach, isObject, isFunction } from "../shared/utils";
+import { isObject, isFunction } from "../shared/utils";
 import {
   applyAnimationClassesFactory,
   applyAnimationStyles,
@@ -218,7 +218,7 @@ export function AnimateJsProvider($animateProvider) {
           fnName,
         ) {
           const operations = [];
-          forEach(animations, (ani) => {
+          animations.forEach((ani) => {
             const animation = ani[fnName];
             if (!animation) return;
 
@@ -326,7 +326,7 @@ export function AnimateJsProvider($animateProvider) {
           return function startAnimation(callback) {
             const runners = [];
             if (operations.length) {
-              forEach(operations, (animateFn) => {
+              operations.forEach((animateFn) => {
                 runners.push(animateFn());
               });
             }
@@ -338,7 +338,7 @@ export function AnimateJsProvider($animateProvider) {
             }
 
             return function endFn(reject) {
-              forEach(runners, (runner) => {
+              runners.forEach((runner) => {
                 if (reject) {
                   runner.cancel();
                 } else {

package/src/animations/animate-queue.js

@@ -1,7 +1,6 @@
 import { getOrSetCacheData, JQLite } from "../shared/jqlite/jqlite";
 import {
   isUndefined,
-  forEach,
   isObject,
   isString,
   isElement,
@@ -195,12 +194,13 @@ export function AnimateQueueProvider($animateProvider) {
       // compiled. The $templateRequest.totalPendingRequests variable keeps track of
       // all of the remote templates being currently downloaded. If there are no
       // templates currently downloading then the watcher will still fire anyway.
+      $rootScope["$templateRequest"] = $templateRequest;
       const deregisterWatch = $rootScope.$watch(
-        () => $templateRequest.totalPendingRequests === 0,
-        (isEmpty) => {
-          if (!isEmpty) return;
+        "$templateRequest.totalPendingRequests",
+        (val) => {
+          if (val !== 0) return;
           deregisterWatch();
-
+          $rootScope["$templateRequest"] = undefined;
           // Now that all templates have been downloaded, $animate will wait until
           // the post digest queue is empty before enabling animations. By having two
           // calls to $postDigest calls we can ensure that the flag is enabled at the
@@ -717,7 +717,7 @@ export function AnimateQueueProvider($animateProvider) {
 
       function closeChildAnimations(node) {
         const children = node.querySelectorAll(`[${NG_ANIMATE_ATTR_NAME}]`);
-        forEach(children, (child) => {
+        children.forEach((child) => {
           const state = parseInt(child.getAttribute(NG_ANIMATE_ATTR_NAME), 10);
           const animationDetails = activeAnimationsLookup.get(child);
           if (animationDetails) {

package/src/animations/animation.js

@@ -1,5 +1,5 @@
 import { JQLite } from "../shared/jqlite/jqlite";
-import { forEach, mergeClasses } from "../shared/utils";
+import { mergeClasses } from "../shared/utils";
 import {
   NG_ANIMATE_CLASSNAME,
   PREPARE_CLASS_SUFFIX,
@@ -326,7 +326,7 @@ export function AnimationProvider() {
             ? [node]
             : node.querySelectorAll(SELECTOR);
           const anchors = [];
-          forEach(items, (node) => {
+          items.forEach((node) => {
             const attr = node.getAttribute(NG_ANIMATE_REF_ATTR);
             if (attr && attr.length) {
               anchors.push(node);
@@ -338,7 +338,7 @@ export function AnimationProvider() {
         function groupAnimations(animations) {
           const preparedAnimations = [];
           const refLookup = {};
-          forEach(animations, (animation, index) => {
+          animations.forEach((animation, index) => {
             const { element } = animation;
             const node = getDomNode(element);
             const { event } = animation;

package/src/animations/shared.js

@@ -1,6 +1,6 @@
-import { forEach, isString, minErr, extend } from "../shared/utils";
-import { JQLite } from "../shared/jqlite/jqlite";
-import { ASTType } from "../core/parser/ast-type";
+import { isString, minErr, extend } from "../shared/utils.js";
+import { JQLite } from "../shared/jqlite/jqlite.js";
+import { ASTType } from "../core/parse/ast-type.js";
 
 export const ADD_CLASS_SUFFIX = "-add";
 export const REMOVE_CLASS_SUFFIX = "-remove";
@@ -262,12 +262,12 @@ export function resolveElementClasses(existing, toAdd, toRemove) {
   existing = splitClassesToLookup(existing);
 
   toAdd = splitClassesToLookup(toAdd);
-  forEach(toAdd, (value, key) => {
+  Object.keys(toAdd).forEach((key) => {
     flags[key] = ADD_CLASS;
   });
 
   toRemove = splitClassesToLookup(toRemove);
-  forEach(toRemove, (value, key) => {
+  Object.keys(toRemove).forEach((key) => {
     flags[key] = flags[key] === ADD_CLASS ? null : REMOVE_CLASS;
   });
 
@@ -276,7 +276,7 @@ export function resolveElementClasses(existing, toAdd, toRemove) {
     removeClass: "",
   };
 
-  forEach(flags, function (val, klass) {
+  Object.entries(flags).forEach(([klass, val]) => {
     var prop, allow;
     if (val === ADD_CLASS) {
       prop = "addClass";
@@ -295,17 +295,19 @@ export function resolveElementClasses(existing, toAdd, toRemove) {
 
   function splitClassesToLookup(classes) {
     if (isString(classes)) {
-      classes = classes.split(" ");
+      classes = classes.trim().split(" ");
     }
 
     const obj = {};
-    forEach(classes, (klass) => {
-      // sometimes the split leaves empty string values
-      // incase extra spaces were applied to the options
-      if (klass.length) {
-        obj[klass] = true;
-      }
-    });
+    if (classes) {
+      classes.forEach((klass) => {
+        // sometimes the split leaves empty string values
+        // incase extra spaces were applied to the options
+        if (klass.length) {
+          obj[klass] = true;
+        }
+      });
+    }
     return obj;
   }
 

package/src/core/compile/attributes.js

@@ -1,6 +1,5 @@
 import { getBooleanAttrName } from "../../shared/jqlite/jqlite";
 import {
-  forEach,
   isString,
   snakeCase,
   isUndefined,
@@ -179,8 +178,8 @@ export class Attributes {
 
     // fire observers
     const { $$observers } = this;
-    if ($$observers) {
-      forEach($$observers[observer], (fn) => {
+    if ($$observers && $$observers[observer]) {
+      $$observers[observer].forEach((fn) => {
         try {
           fn(value);
         } catch (e) {