@angular-wave/angular.ts 0.7.4 → 0.7.7

package/@types/core/scope/scope.d.ts

@@ -150,7 +150,6 @@ export class Scope {
     $destroy: any;
     $eval: any;
     $apply: any;
-    $evalAsync: any;
     $postUpdate: any;
     $isRoot: any;
     $target: any;
@@ -185,7 +184,6 @@ export class Scope {
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
   $eval(expr: any, locals: any): any;
-  $evalAsync(expr: any, locals: any): Promise<any>;
   /**
    * @param {Object} newTarget
    */

package/@types/directive/setter/setter.d.ts

@@ -1,12 +1,12 @@
 /**
  * @param {import('../../core/parse/interface.ts').ParseService} $parse
  * @param {import('../../services/log/interface.ts').LogService} $log
- * @returns {import('../../interface.ts').Directive}
+ * @returns {import('interface.ts').Directive}
  */
 export function ngSetterDirective(
   $parse: import("../../core/parse/interface.ts").ParseService,
   $log: import("../../services/log/interface.ts").LogService,
-): import("../../interface.ts").Directive;
+): any;
 export namespace ngSetterDirective {
   let $inject: string[];
 }

package/@types/shared/utils.d.ts

@@ -525,6 +525,14 @@ export function isObjectEmpty(obj: any | null | undefined): boolean;
  * hasOwn({}, 'bar'); // false
  */
 export function hasOwn(obj: object, key: string | number | symbol): boolean;
+/**
+ * Wraps a function so it can only be called once.
+ * Subsequent calls do nothing and return undefined.
+ *
+ * @param {Function} fn - The function to wrap.
+ * @returns {Function} A new function that will call `fn` only once.
+ */
+export function callBackOnce(fn: Function): Function;
 export const isProxySymbol: unique symbol;
 export const ngAttrPrefixes: string[];
 /**

package/Makefile

@@ -40,7 +40,7 @@ typedoc: types pretty
 serve:
 	@npm run serve
 
-prepare-release: test check types jsdoc pretty build
+prepare-release: test check types typedoc pretty build
 
 PLAYWRIGHT_TEST := npx playwright test
 

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.4 - July 11, 2025 03:03:27 */
+/* Version: 0.7.7 - July 13, 2025 16:59:18 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -241,7 +241,7 @@ function isWindow(obj) {
  * @returns {boolean}
  */
 function isScope(obj) {
-  return obj && obj.$evalAsync && obj.$watch;
+  return obj && obj.$watch;
 }
 
 /**
@@ -1130,6 +1130,24 @@ function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
+/**
+ * Wraps a function so it can only be called once.
+ * Subsequent calls do nothing and return undefined.
+ *
+ * @param {Function} fn - The function to wrap.
+ * @returns {Function} A new function that will call `fn` only once.
+ */
+function callBackOnce(fn) {
+  let called = false;
+
+  return function (...args) {
+    if (!called) {
+      called = true;
+      return fn.apply(this, args);
+    }
+  };
+}
+
 /**
  * Expando cache for adding properties to DOM nodes with JavaScript.
  * This used to be an Object in JQLite decorator, but swapped out for a Map
@@ -3962,31 +3980,28 @@ function SceProvider() {
  */
 const ngEventDirectives = {};
 
-"click copy cut dblclick focus blur keydown keyup keypress load mouseover mousein mouseout mouseleave paste submit touchstart touchend touchmove"
+"click copy cut dblclick focus blur keydown keyup load mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup paste submit touchstart touchend touchmove"
   .split(" ")
-  .forEach(
-    /** @param { string } eventName */
-    (eventName) => {
-      const directiveName = directiveNormalize(`ng-${eventName}`);
-      ngEventDirectives[directiveName] = [
-        "$parse",
-        "$exceptionHandler",
-        /**
-         * @param {import("../../core/parse/interface.ts").ParseService} $parse
-         * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
-         * @returns
-         */
-        ($parse, $exceptionHandler) => {
-          return createEventDirective(
-            $parse,
-            $exceptionHandler,
-            directiveName,
-            eventName,
-          );
-        },
-      ];
-    },
-  );
+  .forEach((eventName) => {
+    const directiveName = directiveNormalize(`ng-${eventName}`);
+    ngEventDirectives[directiveName] = [
+      "$parse",
+      "$exceptionHandler",
+      /**
+       * @param {import("../../core/parse/interface.ts").ParseService} $parse
+       * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
+       * @returns
+       */
+      ($parse, $exceptionHandler) => {
+        return createEventDirective(
+          $parse,
+          $exceptionHandler,
+          directiveName,
+          eventName,
+        );
+      },
+    ];
+  });
 
 /**
  *
@@ -11219,9 +11234,15 @@ function ngBindDirective() {
      * @param {import('../../core/compile/attributes.js').Attributes} attr
      */
     link(scope, element, attr) {
-      scope.$watch(attr["ngBind"], (value) => {
-        element.textContent = stringify$1(isProxy(value) ? value.$target : value);
-      });
+      scope.$watch(
+        attr["ngBind"],
+        (value) => {
+          element.textContent = stringify$1(
+            isProxy(value) ? value.$target : value,
+          );
+        },
+        isDefined(attr["lazy"]),
+      );
     },
   };
 }
@@ -11948,7 +11969,7 @@ function ngRepeatDirective($animate) {
     transclude: "element",
     priority: 1000,
     terminal: true,
-    compile: (_$element, $attr) => {
+    compile: ($element, $attr) => {
       const expression = $attr["ngRepeat"];
       const hasAnimate = !!$attr["animate"];
 
@@ -11994,6 +12015,14 @@ function ngRepeatDirective($animate) {
         );
       }
 
+      const swap = callBackOnce(() => {
+        if (isDefined($attr["lazy"]) && isDefined($attr["swap"])) {
+          document
+            .querySelectorAll($attr["swap"])
+            .forEach((x) => removeElement(x));
+        }
+      });
+
       return function ngRepeatLink($scope, $element, $attr, ctrl, $transclude) {
         // Store a list of elements from previous run. This is a hash where key is the item from the
         // iterator, and the value is objects with following properties.
@@ -12005,174 +12034,181 @@ function ngRepeatDirective($animate) {
         // hasOwnProperty.
         let lastBlockMap = Object.create(null);
         // watch props
-        $scope.$watch(rhs, (collection) => {
-          let index,
-            length,
-            previousNode = $element, // node that cloned nodes should be inserted after
-            // initialized to the comment node anchor
-            nextNode;
-          const // Same as lastBlockMap but it has the current state. It will become the
-            // lastBlockMap on the next iteration.
-            nextBlockMap = Object.create(null);
-          let collectionLength,
-            key,
-            value, // key/value of iteration
-            trackById,
-            trackByIdFn,
-            collectionKeys,
-            block, // last object information {scope, element, id}
-            nextBlockOrder,
-            elementsToRemove;
-
-          if (aliasAs) {
-            $scope[aliasAs] = collection;
-          }
-
-          if (isArrayLike(collection)) {
-            collectionKeys = collection;
-            trackByIdFn = trackByIdArrayFn;
-          } else {
-            trackByIdFn = trackByIdObjFn;
-            // if object, extract keys, in enumeration order, unsorted
-            collectionKeys = [];
-            for (const itemKey in collection) {
-              if (hasOwn(collection, itemKey) && itemKey.charAt(0) !== "$") {
-                collectionKeys.push(itemKey);
-              }
+        $scope.$watch(
+          rhs,
+          (collection) => {
+            swap();
+            let index,
+              length,
+              previousNode = $element, // node that cloned nodes should be inserted after
+              // initialized to the comment node anchor
+              nextNode;
+            const // Same as lastBlockMap but it has the current state. It will become the
+              // lastBlockMap on the next iteration.
+              nextBlockMap = Object.create(null);
+            let collectionLength,
+              key,
+              value, // key/value of iteration
+              trackById,
+              trackByIdFn,
+              collectionKeys,
+              block, // last object information {scope, element, id}
+              nextBlockOrder,
+              elementsToRemove;
+
+            if (aliasAs) {
+              $scope[aliasAs] = collection;
             }
-          }
 
-          collectionLength = collectionKeys.length;
-          nextBlockOrder = new Array(collectionLength);
-
-          // locate existing items
-          for (index = 0; index < collectionLength; index++) {
-            key = collection === collectionKeys ? index : collectionKeys[index];
-            value = collection[key];
-            trackById = trackByIdFn($scope, key, value);
-            if (lastBlockMap[trackById]) {
-              // found previously seen block
-              block = lastBlockMap[trackById];
-              delete lastBlockMap[trackById];
-              nextBlockMap[trackById] = block;
-              nextBlockOrder[index] = block;
-            } else if (nextBlockMap[trackById]) {
-              // if collision detected. restore lastBlockMap and throw an error
-              Object.values(nextBlockOrder).forEach((block) => {
-                if (block && block.scope) lastBlockMap[block.id] = block;
-              });
-              throw ngRepeatMinErr(
-                "dupes",
-                "Duplicates keys in a repeater are not allowed. Repeater: {0}, Duplicate key: {1} for value: {2}",
-                expression,
-                trackById,
-                value,
-              );
+            if (isArrayLike(collection)) {
+              collectionKeys = collection;
+              trackByIdFn = trackByIdArrayFn;
             } else {
-              // new never before seen block
-              nextBlockOrder[index] = {
-                id: trackById,
-                scope: undefined,
-                clone: undefined,
-              };
-              nextBlockMap[trackById] = true;
+              trackByIdFn = trackByIdObjFn;
+              // if object, extract keys, in enumeration order, unsorted
+              collectionKeys = [];
+              for (const itemKey in collection) {
+                if (hasOwn(collection, itemKey) && itemKey.charAt(0) !== "$") {
+                  collectionKeys.push(itemKey);
+                }
+              }
             }
-          }
 
-          // remove leftover items
-          for (let blockKey in lastBlockMap) {
-            block = lastBlockMap[blockKey];
-            elementsToRemove = block.clone;
-            if (hasAnimate) {
-              $animate.leave(elementsToRemove);
-            } else {
-              elementsToRemove.remove();
+            collectionLength = collectionKeys.length;
+            nextBlockOrder = new Array(collectionLength);
+
+            // locate existing items
+            for (index = 0; index < collectionLength; index++) {
+              key =
+                collection === collectionKeys ? index : collectionKeys[index];
+              value = collection[key];
+              trackById = trackByIdFn($scope, key, value);
+              if (lastBlockMap[trackById]) {
+                // found previously seen block
+                block = lastBlockMap[trackById];
+                delete lastBlockMap[trackById];
+                nextBlockMap[trackById] = block;
+                nextBlockOrder[index] = block;
+              } else if (nextBlockMap[trackById]) {
+                // if collision detected. restore lastBlockMap and throw an error
+                Object.values(nextBlockOrder).forEach((block) => {
+                  if (block && block.scope) lastBlockMap[block.id] = block;
+                });
+                throw ngRepeatMinErr(
+                  "dupes",
+                  "Duplicates keys in a repeater are not allowed. Repeater: {0}, Duplicate key: {1} for value: {2}",
+                  expression,
+                  trackById,
+                  value,
+                );
+              } else {
+                // new never before seen block
+                nextBlockOrder[index] = {
+                  id: trackById,
+                  scope: undefined,
+                  clone: undefined,
+                };
+                nextBlockMap[trackById] = true;
+              }
             }
-            if (elementsToRemove.parentNode) {
-              // if the element was not removed yet because of pending animation, mark it as deleted
-              // so that we can ignore it later
-              for (
-                index = 0, length = elementsToRemove.length;
-                index < length;
-                index++
-              ) {
-                elementsToRemove[index][NG_REMOVED] = true;
+
+            // remove leftover items
+            for (let blockKey in lastBlockMap) {
+              block = lastBlockMap[blockKey];
+              elementsToRemove = block.clone;
+              if (hasAnimate) {
+                $animate.leave(elementsToRemove);
+              } else {
+                elementsToRemove.remove();
+              }
+              if (elementsToRemove.parentNode) {
+                // if the element was not removed yet because of pending animation, mark it as deleted
+                // so that we can ignore it later
+                for (
+                  index = 0, length = elementsToRemove.length;
+                  index < length;
+                  index++
+                ) {
+                  elementsToRemove[index][NG_REMOVED] = true;
+                }
               }
+              block.scope.$destroy();
             }
-            block.scope.$destroy();
-          }
 
-          for (index = 0; index < collectionLength; index++) {
-            key = collection === collectionKeys ? index : collectionKeys[index];
-            value = collection[key];
-            block = nextBlockOrder[index];
+            for (index = 0; index < collectionLength; index++) {
+              key =
+                collection === collectionKeys ? index : collectionKeys[index];
+              value = collection[key];
+              block = nextBlockOrder[index];
 
-            if (block.scope) {
-              // if we have already seen this object, then we need to reuse the
-              // associated scope/element
+              if (block.scope) {
+                // if we have already seen this object, then we need to reuse the
+                // associated scope/element
 
-              nextNode = previousNode;
+                nextNode = previousNode;
 
-              // skip nodes that are already pending removal via leave animation
-              do {
-                nextNode = nextNode.nextSibling;
-              } while (nextNode && nextNode[NG_REMOVED]);
+                // skip nodes that are already pending removal via leave animation
+                do {
+                  nextNode = nextNode.nextSibling;
+                } while (nextNode && nextNode[NG_REMOVED]);
 
-              if (getBlockStart(block) !== nextNode) {
-                // existing item which got moved
-                $animate.move(getBlockNodes(block.clone), null, previousNode);
-              }
-              previousNode = getBlockEnd(block);
-              updateScope(
-                block.scope,
-                index,
-                valueIdentifier,
-                value,
-                keyIdentifier,
-                key,
-                collectionLength,
-              );
-            } else {
-              // new item which we don't know about
-              $transclude(
-                /**
-                 * Clone attach function
-                 * @param {Array<NodeList>} clone
-                 * @param {import("../../core/scope/scope.js").Scope} scope
-                 */
-
-                (clone, scope) => {
-                  block.scope = scope;
-                  const endNode = clone;
-                  if (hasAnimate) {
-                    $animate.enter(clone, null, previousNode);
-                  } else {
-                    // @ts-ignore
-                    previousNode.after(clone);
-                  }
+                if (getBlockStart(block) !== nextNode) {
+                  // existing item which got moved
+                  $animate.move(getBlockNodes(block.clone), null, previousNode);
+                }
+                previousNode = getBlockEnd(block);
+                updateScope(
+                  block.scope,
+                  index,
+                  valueIdentifier,
+                  value,
+                  keyIdentifier,
+                  key,
+                  collectionLength,
+                );
+              } else {
+                // new item which we don't know about
+                $transclude(
+                  /**
+                   * Clone attach function
+                   * @param {Array<NodeList>} clone
+                   * @param {import("../../core/scope/scope.js").Scope} scope
+                   */
 
-                  // @ts-ignore
-                  previousNode = endNode;
-                  // Note: We only need the first/last node of the cloned nodes.
-                  // However, we need to keep the reference to the dom wrapper as it might be changed later
-                  // by a directive with templateUrl when its template arrives.
-                  block.clone = clone;
-                  nextBlockMap[block.id] = block;
-                  updateScope(
-                    block.scope,
-                    index,
-                    valueIdentifier,
-                    value,
-                    keyIdentifier,
-                    key,
-                    collectionLength,
-                  );
-                },
-              );
+                  (clone, scope) => {
+                    block.scope = scope;
+                    const endNode = clone;
+                    if (hasAnimate) {
+                      $animate.enter(clone, null, previousNode);
+                    } else {
+                      // @ts-ignore
+                      previousNode.after(clone);
+                    }
+
+                    // @ts-ignore
+                    previousNode = endNode;
+                    // Note: We only need the first/last node of the cloned nodes.
+                    // However, we need to keep the reference to the dom wrapper as it might be changed later
+                    // by a directive with templateUrl when its template arrives.
+                    block.clone = clone;
+                    nextBlockMap[block.id] = block;
+                    updateScope(
+                      block.scope,
+                      index,
+                      valueIdentifier,
+                      value,
+                      keyIdentifier,
+                      key,
+                      collectionLength,
+                    );
+                  },
+                );
+              }
             }
-          }
-          lastBlockMap = nextBlockMap;
-        });
+            lastBlockMap = nextBlockMap;
+          },
+          isDefined($attr["lazy"]),
+        );
       };
     },
   };
@@ -13556,7 +13592,7 @@ class AnchorScrollProvider {
           // skip the initial scroll if $location.hash is empty
           if (newVal === oldVal && newVal === "") return;
 
-          const action = () => $rootScope.$evalAsync(scroll);
+          const action = () => Promise.resolve().then(scroll);
           if (document.readyState === "complete") {
             // Force the action to be run async for consistent behavior
             // from the action's point of view
@@ -19998,7 +20034,7 @@ class LocationProvider {
           return;
         }
 
-        $rootScope.$evalAsync(() => {
+        Promise.resolve().then(() => {
           const oldUrl = $location.absUrl();
           const oldState = $location.$$state;
           let defaultPrevented;
@@ -20726,7 +20762,6 @@ class Scope {
       $destroy: this.$destroy.bind(this),
       $eval: this.$eval.bind(this),
       $apply: this.$apply.bind(this),
-      $evalAsync: this.$evalAsync.bind(this),
       $postUpdate: this.$postUpdate.bind(this),
       $isRoot: this.#isRoot.bind(this),
       $target: target,
@@ -21232,10 +21267,6 @@ class Scope {
     return res;
   }
 
-  async $evalAsync(expr, locals) {
-    return await this.$eval(expr, locals);
-  }
-
   /**
    * @param {Object} newTarget
    */
@@ -21978,7 +22009,7 @@ class NgMessageCtrl {
   reRender() {
     if (!this.renderLater) {
       this.renderLater = true;
-      this.$scope.$evalAsync(() => {
+      Promise.resolve().then(() => {
         if (this.renderLater && this.cachedCollection) {
           this.render(this.cachedCollection);
         }
@@ -35093,12 +35124,10 @@ function $StateRefActiveDirective(
         const removeClasses = allClasses.filter(
           (cls) => !addClasses.includes(cls),
         );
-        $scope.$evalAsync(() => {
-          addClasses.forEach((className) => $element.classList.add(className));
-          removeClasses.forEach((className) =>
-            $element.classList.remove(className),
-          );
-        });
+        addClasses.forEach((className) => $element.classList.add(className));
+        removeClasses.forEach((className) =>
+          $element.classList.remove(className),
+        );
       }
       update();
     },
@@ -35606,7 +35635,7 @@ ngSetterDirective.$inject = ["$parse", "$log"];
 /**
  * @param {import('../../core/parse/interface.ts').ParseService} $parse
  * @param {import('../../services/log/interface.ts').LogService} $log
- * @returns {import('../../interface.ts').Directive}
+ * @returns {import('interface.ts').Directive}
  */
 function ngSetterDirective($parse, $log) {
   return {
@@ -36091,7 +36120,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.7.4"; //inserted via rollup plugin
+    this.version = "0.7.7"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];