@angular-wave/angular.ts 0.0.54 → 0.0.55

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/animations/animate-cache.js

@@ -1,50 +1,75 @@
-const KEY = "$$ngAnimateParentKey";
+const KEY = "$animId";
 let parentCounter = 0;
-let cache = Object.create(null);
+const cache = new Map();
 
 export function animateCache() {
   return {
+    /**
+     * Generates a unique cache key based on the node's parent and other parameters.
+     * @param {HTMLElement} node - The DOM node to generate the cache key for.
+     * @param {string} method - The animation method being applied.
+     * @param {string} [addClass] - Class to add during the animation.
+     * @param {string} [removeClass] - Class to remove during the animation.
+     * @returns {string} - The generated cache key.
+     */
     cacheKey(node, method, addClass, removeClass) {
       const { parentNode } = node;
-      const parentID = parentNode[KEY] || (parentNode[KEY] = ++parentCounter);
+      const parentID = parentNode[KEY] ?? (parentNode[KEY] = ++parentCounter);
       const parts = [parentID, method, node.getAttribute("class")];
-      if (addClass) {
-        parts.push(addClass);
-      }
-      if (removeClass) {
-        parts.push(removeClass);
-      }
+      if (addClass) parts.push(addClass);
+      if (removeClass) parts.push(removeClass);
       return parts.join(" ");
     },
 
+    /**
+     * Checks if a cached animation without a duration exists.
+     * @param {string} key - The cache key to check.
+     * @returns {boolean} - True if an invalid animation is cached, false otherwise.
+     */
     containsCachedAnimationWithoutDuration(key) {
-      const entry = cache[key];
-
-      // nothing cached, so go ahead and animate
-      // otherwise it should be a valid animation
-      return (entry && !entry.isValid) || false;
+      const entry = cache.get(key);
+      return entry ? !entry.isValid : false;
     },
 
+    /**
+     * Clears the cache.
+     * @returns {void}
+     */
     flush() {
-      cache = Object.create(null);
+      cache.clear();
     },
 
+    /**
+     * Gets the count of a specific cache entry.
+     * @param {string} key - The cache key to count.
+     * @returns {number} - The count of the cache entry.
+     */
     count(key) {
-      const entry = cache[key];
-      return entry ? entry.total : 0;
+      return cache.get(key)?.total ?? 0;
     },
 
+    /**
+     * Retrieves a value associated with a specific cache key.
+     * @param {string} key - The cache key to retrieve.
+     * @returns {any} - The value associated with the cache key.
+     */
     get(key) {
-      const entry = cache[key];
-      return entry && entry.value;
+      return cache.get(key)?.value;
     },
 
+    /**
+     * Adds or updates a cache entry.
+     * @param {string} key - The cache key to add or update.
+     * @param {any} value - The value to store.
+     * @param {boolean} isValid - Whether the cache entry is valid.
+     */
     put(key, value, isValid) {
-      if (!cache[key]) {
-        cache[key] = { total: 1, value, isValid };
+      const entry = cache.get(key);
+      if (entry) {
+        entry.total++;
+        entry.value = value;
       } else {
-        cache[key].total++;
-        cache[key].value = value;
+        cache.set(key, { total: 1, value, isValid });
       }
     },
   };

package/src/animations/animate-children-directive.js

@@ -2,6 +2,11 @@ import { isString } from "../shared/utils";
 import { NG_ANIMATE_CHILDREN_DATA } from "./shared";
 
 $$AnimateChildrenDirective.$inject = ["$interpolate"];
+
+/**
+ * @param {*} $interpolate
+ * @returns {import("../types").Directive}
+ */
 export function $$AnimateChildrenDirective($interpolate) {
   return {
     link(scope, element, attrs) {

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

@@ -23,9 +23,16 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
     "$animateCss",
     "$$AnimateRunner",
     "$rootElement",
+    /**
+     *
+     * @param {*} $animateCss
+     * @param {typeof import('../core/animate/animate-runner').AnimateRunner} $$AnimateRunner
+     * @param {*} $rootElement
+     * @returns
+     */
     function ($animateCss, $$AnimateRunner, $rootElement) {
       const bodyNode = document.body;
-      const rootNode = getDomNode($rootElement);
+      const rootNode = $rootElement[0];
 
       const rootBodyElement = JQLite(
         // this is to avoid using something that exists outside of the body
@@ -41,24 +48,12 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
           ? prepareFromToAnchorAnimation(
               animationDetails.from,
               animationDetails.to,
-              animationDetails.classes,
               animationDetails.anchors,
             )
           : prepareRegularAnimation(animationDetails);
       };
 
-      function filterCssClasses(classes) {
-        // remove all the `ng-` stuff
-        return classes.replace(/\bng-\S+\b/g, "");
-      }
-
-      function getUniqueValues(a, b) {
-        if (isString(a)) a = a.split(" ");
-        if (isString(b)) b = b.split(" ");
-        return a.filter((val) => b.indexOf(val) === -1).join(" ");
-      }
-
-      function prepareAnchoredAnimation(classes, outAnchor, inAnchor) {
+      function prepareAnchoredAnimation(outAnchor, inAnchor) {
         const clone = JQLite(getDomNode(outAnchor).cloneNode(true));
         const startingClasses = filterCssClasses(getClassVal(clone));
 
@@ -186,19 +181,15 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
         }
       }
 
-      function prepareFromToAnchorAnimation(from, to, classes, anchors) {
+      function prepareFromToAnchorAnimation(from, to, anchors) {
         const fromAnimation = prepareRegularAnimation(from);
         const toAnimation = prepareRegularAnimation(to);
 
         const anchorAnimations = [];
-        forEach(anchors, (anchor) => {
+        anchors.forEach((anchor) => {
           const outElement = anchor.out;
           const inElement = anchor.in;
-          const animator = prepareAnchoredAnimation(
-            classes,
-            outElement,
-            inElement,
-          );
+          const animator = prepareAnchoredAnimation(outElement, inElement);
           if (animator) {
             anchorAnimations.push(animator);
           }
@@ -236,7 +227,7 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
             return runner;
 
             function endFn() {
-              forEach(animationRunners, (runner) => {
+              animationRunners.forEach((runner) => {
                 runner.end();
               });
             }
@@ -245,7 +236,6 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
       }
 
       function prepareRegularAnimation(animationDetails) {
-        const { element } = animationDetails;
         const options = animationDetails.options || {};
 
         if (animationDetails.structural) {
@@ -271,14 +261,26 @@ export function $$AnimateCssDriverProvider($$animationProvider) {
           );
         }
 
-        const animator = $animateCss(element, options);
+        const animator = $animateCss(animationDetails.element, options);
 
         // the driver lookup code inside of $$animation attempts to spawn a
         // driver one by one until a driver returns a.$$willAnimate animator object.
         // $animateCss will always return an object, however, it will pass in
         // a flag as a hint as to whether an animation was detected or not
+
         return animator.$$willAnimate ? animator : null;
       }
     },
   ];
 }
+
+function filterCssClasses(classes) {
+  // remove all the `ng-` stuff
+  return classes.replace(/\bng-\S+\b/g, "");
+}
+
+function getUniqueValues(a, b) {
+  if (isString(a)) a = a.split(" ");
+  if (isString(b)) b = b.split(" ");
+  return a.filter((val) => b.indexOf(val) === -1).join(" ");
+}

package/src/animations/animate-css.html

@@ -0,0 +1,40 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+
+    <!--     
+    <script src="https://cdn.jsdelivr.net/npm/angular@1.8.3/angular.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/angular-animate@1.8.3/angular-animate.js"></script>
+    <script>window.angular.module("test", ["ngAnimate"])</script> -->
+
+    <script type="module" src="/src/index.js"></script>
+    <script>
+      document.addEventListener("DOMContentLoaded", () => {
+        window.angular.module("test", ["ngAnimate"]);
+      });
+    </script>
+
+    <style>
+      /* The starting CSS styles for the enter animation */
+      .fade.ng-enter {
+        transition: 0.5s linear all;
+        opacity: 0;
+      }
+
+      /* The finishing CSS styles for the enter animation */
+      .fade.ng-enter.ng-enter-active {
+        opacity: 1;
+        background-color: red;
+      }
+    </style>
+  </head>
+  <body ng-app="test">
+    <div ng-if="bool" class="fade">Fade me in out</div>
+    <button ng-click="bool=true">Fade In!</button>
+    <button ng-click="bool=false">Fade Out!</button>
+  </body>
+</html>

package/src/animations/animate-css.js

@@ -155,7 +155,6 @@ export function $AnimateCssProvider() {
 
       function computeCachedCssStyles(
         node,
-        className,
         cacheKey,
         allowNoDuration,
         properties,
@@ -247,10 +246,9 @@ export function $AnimateCssProvider() {
         });
       }
 
-      function computeTimings(node, className, cacheKey, allowNoDuration) {
+      function computeTimings(node, cacheKey, allowNoDuration) {
         const timings = computeCachedCssStyles(
           node,
-          className,
           cacheKey,
           allowNoDuration,
           DETECT_CSS_PROPERTIES,
@@ -343,7 +341,6 @@ export function $AnimateCssProvider() {
         let preparationClasses = [structuralClassName, addRemoveClassName]
           .join(" ")
           .trim();
-        let fullClassName = `${classes} ${preparationClasses}`;
         const hasToStyles = styles.to && Object.keys(styles.to).length > 0;
         const containsKeyframeAnimation =
           (options.keyframeStyle || "").length > 0;
@@ -405,6 +402,7 @@ export function $AnimateCssProvider() {
 
           // we set the duration so that it will be picked up by getComputedStyle later
           applyInlineStyle(node, durationStyle);
+
           temporaryStyles.push(durationStyle);
         }
 
@@ -432,12 +430,7 @@ export function $AnimateCssProvider() {
           blockTransitions(node, SAFE_FAST_FORWARD_DURATION_VALUE);
         }
 
-        let timings = computeTimings(
-          node,
-          fullClassName,
-          cacheKey,
-          !isStructural,
-        );
+        let timings = computeTimings(node, cacheKey, !isStructural);
         let relativeDelay = timings.maxDelay;
         maxDelay = Math.max(relativeDelay, 0);
         maxDuration = timings.maxDuration;
@@ -485,7 +478,7 @@ export function $AnimateCssProvider() {
           return closeAndReturnNoopAnimator();
         }
 
-        const activeClasses = pendClasses(
+        var activeClasses = pendClasses(
           preparationClasses,
           ACTIVE_CLASS_SUFFIX,
         );
@@ -585,15 +578,15 @@ export function $AnimateCssProvider() {
           animationPaused = false;
 
           if (preparationClasses && !options.$$skipPreparationClasses) {
-            preparationClasses
-              .split(" ")
-              .forEach((cls) => element.classList.remove(cls));
+            preparationClasses.split(" ").forEach(function (cls) {
+              element[0].classList.remove(cls);
+            });
           }
-
+          activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
           if (activeClasses) {
-            activeClasses
-              .split(" ")
-              .forEach((cls) => element.classList.remove(cls));
+            activeClasses.split(" ").forEach(function (cls) {
+              element[0].classList.remove(cls);
+            });
           }
 
           blockKeyframeAnimations(node, false);
@@ -782,7 +775,8 @@ export function $AnimateCssProvider() {
             });
 
             applyAnimationClasses(element, options);
-            element.className += ` ${activeClasses}`;
+
+            element[0].classList.add(activeClasses);
             if (flags.recalculateTimingStyles) {
               fullClassName = `${node.getAttribute("class")} ${preparationClasses}`;
               cacheKey = $$animateCache.cacheKey(
@@ -792,7 +786,7 @@ export function $AnimateCssProvider() {
                 options.removeClass,
               );
 
-              timings = computeTimings(node, fullClassName, cacheKey, false);
+              timings = computeTimings(node, cacheKey, false);
               relativeDelay = timings.maxDelay;
               maxDelay = Math.max(relativeDelay, 0);
               maxDuration = timings.maxDuration;

package/src/animations/animate-queue.js

@@ -391,7 +391,7 @@ export function $$AnimateQueueProvider($animateProvider) {
         // we always make a copy of the options since
         // there should never be any side effects on
         // the input data when running `$animateCss`.
-        let options = structuredClone(initialOptions);
+        let options = initialOptions;
 
         let element = stripCommentsFromElement(originalElement);
         const node = getDomNode(element);

package/src/animations/animation.js

@@ -196,7 +196,7 @@ export function $$AnimationProvider() {
 
         $rootScope.$$postDigest(() => {
           const animations = [];
-          forEach(animationQueue, (entry) => {
+          animationQueue.forEach((entry) => {
             // the element was destroyed early on which removed the runner
             // form its storage. This means we can't animate this element
             // at all and it already has been closed due to destruction.
@@ -213,7 +213,7 @@ export function $$AnimationProvider() {
           const groupedAnimations = groupAnimations(animations);
           const toBeSortedAnimations = [];
 
-          forEach(groupedAnimations, (animationEntry) => {
+          groupedAnimations.forEach((animationEntry) => {
             const element = animationEntry.from
               ? animationEntry.from.element
               : animationEntry.element;
@@ -342,7 +342,7 @@ export function $$AnimationProvider() {
             if (anchorNodes.length) {
               const direction = enterOrMove ? "to" : "from";
 
-              forEach(anchorNodes, (anchor) => {
+              anchorNodes.forEach((anchor) => {
                 const key = anchor.getAttribute(NG_ANIMATE_REF_ATTR);
                 refLookup[key] = refLookup[key] || {};
                 refLookup[key][direction] = {

package/src/animations/shared.js

@@ -303,6 +303,11 @@ export function resolveElementClasses(existing, toAdd, toRemove) {
   return classes;
 }
 
+/**
+ *
+ * @param {JQLite|Element} element
+ * @returns {Element}
+ */
 export function getDomNode(element) {
   return element instanceof JQLite ? element[0] : element;
 }

package/src/core/animate/animate-runner.js

@@ -50,7 +50,7 @@ export function AnimateRunnerFactoryProvider() {
   ];
 }
 
-class AnimateRunner {
+export class AnimateRunner {
   static chain(chain, callback) {
     let index = 0;
 

package/src/core/animate/animate.spec.js

@@ -483,7 +483,6 @@ describe("$animate", () => {
 
         element = JQLite('<svg><g class="test-class4"></g></svg>');
         const target = element.children().eq(0);
-        debugger;
         $animate.addClass(target, "test-class1");
         $animate.removeClass(target, "test-class1");
         $animate.addClass(target, "test-class2");

package/src/loader.js

@@ -183,7 +183,6 @@ export class Angular {
     };
 
     this.doBootstrap = function () {
-      // @ts-ignore
       element = JQLite(element);
 
       if (element.injector()) {

package/src/router/params/param-type.js

@@ -51,7 +51,6 @@ export class ParamType {
   }
   /** @inheritdoc */
   equals(a, b) {
-    // tslint:disable-next-line:triple-equals
     return a == b;
   }
   $subPattern() {

package/src/router/params/param-types.js

@@ -87,7 +87,7 @@ function initDefaultTypes() {
       decode: valToString,
       is: is(String),
       pattern: /.*/,
-      // tslint:disable-next-line:triple-equals
+
       equals: (a, b) => a == b, // allow coersion for null/undefined/""
     };
     return Object.assign({}, defaultTypeBase, def);

package/src/router/params/param.js

@@ -4,10 +4,12 @@ import { isInjectable } from "../../shared/predicates";
 import { isDefined, isUndefined, isString } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { ParamType } from "./param-type";
-const hasOwn = Object.prototype.hasOwnProperty;
+
 const isShorthand = (cfg) =>
-  ["value", "type", "squash", "array", "dynamic"].filter(hasOwn.bind(cfg || {}))
-    .length === 0;
+  ["value", "type", "squash", "array", "dynamic"].filter(
+    Object.prototype.hasOwnProperty.bind(cfg || {}),
+  ).length === 0;
+
 var DefType;
 (function (DefType) {
   DefType[(DefType["PATH"] = 0)] = "PATH";
@@ -15,6 +17,7 @@ var DefType;
   DefType[(DefType["CONFIG"] = 2)] = "CONFIG";
 })(DefType || (DefType = {}));
 export { DefType };
+
 function getParamDeclaration(paramName, location, state) {
   const noReloadOnSearch =
     (state.reloadOnSearch === false && location === DefType.SEARCH) ||

package/src/router/resolve/resolve-context.js

@@ -21,7 +21,6 @@ export let resolvePolicies = {
 const whens = resolvePolicies.when;
 const ALL_WHENS = [whens.EAGER, whens.LAZY];
 const EAGER_WHENS = [whens.EAGER];
-// tslint:disable-next-line:no-inferrable-types
 export const NATIVE_INJECTOR_TOKEN = "Native Injector";
 /**
  * Encapsulates Dependency Injection for a path of nodes

package/src/router/state/state.spec.js

@@ -431,15 +431,12 @@ describe("$state", () => {
         $stateProvider.state(childNoParam);
 
         $transitions.onEnter({}, function (trans, state) {
-          console.log("enter");
           dynlog += "enter:" + state.name + ";";
         });
         $transitions.onExit({}, function (trans, state) {
-          console.log("exit");
           dynlog += "exit:" + state.name + ";";
         });
         $transitions.onSuccess({}, function () {
-          console.log("success");
           dynlog += "success;";
         });
 

package/src/router/transition/transition-event-type.js

@@ -4,7 +4,6 @@ import { TransitionHook } from "./transition-hook";
  * Plugins can define custom hook types, such as sticky states does for `onInactive`.
  */
 export class TransitionEventType {
-  /* tslint:disable:no-inferrable-types */
   constructor(
     name,
     hookPhase,

package/src/router/transition/transition.js

@@ -455,7 +455,6 @@ export class Transition {
   redirect(targetState) {
     let redirects = 1,
       trans = this;
-    // tslint:disable-next-line:no-conditional-assignment
     while ((trans = trans.redirectedFrom()) != null) {
       if (++redirects > 20)
         throw new Error(`Too many consecutive Transition redirects (20+)`);

package/src/router/url/url-matcher.js

@@ -249,7 +249,6 @@ export class UrlMatcher {
     };
     let details;
     let segment;
-    // tslint:disable-next-line:no-conditional-assignment
     while ((matchArray = placeholder.exec(pattern))) {
       details = matchDetails(matchArray, false);
       if (details.segment.indexOf("?") >= 0) break; // we're into the search part
@@ -269,7 +268,6 @@ export class UrlMatcher {
       segment = segment.substring(0, i);
       if (search.length > 0) {
         last = 0;
-        // tslint:disable-next-line:no-conditional-assignment
         while ((matchArray = searchPlaceholder.exec(search))) {
           details = matchDetails(matchArray, true);
           checkParamErrors(details.id);

package/src/shared/common.js

@@ -1,16 +1,6 @@
-/**
- * Random utility functions used in the ng-router code
- *
- * These functions are exported, but are subject to change without notice.
- *
- */
 import { isDate, isFunction, isRegExp, isString } from "./utils";
 import { all, any, prop, curry, not } from "./hof";
 import { services } from "../router/common/coreservices";
-export const root =
-  (typeof self === "object" && self.self === self && self) ||
-  (typeof global === "object" && global.global === global && global) ||
-  this;
 export const fromJson = JSON.parse.bind(JSON);
 export const toJson = JSON.stringify.bind(JSON);
 export const forEach = _forEach;
@@ -158,7 +148,6 @@ export const mergeR = (memo, item) => Object.assign(memo, item);
  */
 export function ancestors(first, second) {
   const path = [];
-  // tslint:disable-next-line:forin
   for (const n in first.path) {
     if (first.path[n] !== second.path[n]) break;
     path.push(first.path[n]);
@@ -476,7 +465,7 @@ function _equals(o1, o2) {
   if (predicates.map(any).reduce((b, fn) => b || !!fn(tup), false))
     return false;
   const keys = {};
-  // tslint:disable-next-line:forin
+
   for (const key in o1) {
     if (!_equals(o1[key], o2[key])) return false;
     keys[key] = true;

package/src/shared/hof.js

@@ -133,7 +133,6 @@ export function or(fn1, fn2) {
  * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
  */
 export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
-// tslint:disable-next-line:variable-name
 export const any = (fn1) => (arr) => arr.reduce((b, x) => b || !!fn1(x), false);
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
 export const is = (ctor) => (obj) =>