@angular-wave/angular.ts 0.7.1 → 0.7.3

package/dist/angular-ts.umd.js

@@ -1,8 +1,9 @@
-/* Version: 0.7.0 - June 28, 2025 13:06:07 */
-(function (factory) {
-  typeof define === 'function' && define.amd ? define(factory) :
-  factory();
-})((function () { 'use strict';
+/* Version: 0.7.3 - July 4, 2025 23:40:50 */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.angular = {}));
+})(this, (function (exports) { 'use strict';
 
   const VALID_CLASS = "ng-valid";
   const INVALID_CLASS = "ng-invalid";
@@ -1137,10 +1138,7 @@
 
   /**
    * @typedef {Object} ExpandoStore
-   *
    * @property {!Object<string, any>} data
-   * @property {!Object} events
-   * @property {?Function} handle
    *
    */
 
@@ -1277,9 +1275,7 @@
     if (createIfNecessary && !expandoStore) {
       element[EXPANDO] = expandoId = jqNextId();
       expandoStore = {
-        events: {},
         data: {},
-        handle: null,
       };
       Cache.set(expandoId, expandoStore);
     }
@@ -1338,19 +1334,15 @@
   }
 
   /**
-   * If `ExpandoStore.data` and `ExpandoStore.events` are empty,
-   * then delete element's `ExpandoStore` and set its `ExpandoId`
+   * If expando store data is empty, then delete it and set its expando id.
    * to undefined.
    * @param {Element} element
    */
   function removeIfEmptyData(element) {
     const expandoId = element[EXPANDO];
-    const { events, data } = Cache.get(expandoId);
+    const { data } = Cache.get(expandoId);
 
-    if (
-      (!data || !Object.keys(data).length) &&
-      (!events || !Object.keys(events).length)
-    ) {
+    if (!data || !Object.keys(data).length) {
       Cache.delete(expandoId);
       element[EXPANDO] = undefined; // don't delete DOM expandos. Chrome don't like it
     }
@@ -1627,10 +1619,6 @@
    */
   function cleanElementData(nodes) {
     for (let i = 0, ii = nodes.length; i < ii; i++) {
-      const events = (Cache.get(nodes[i][EXPANDO]) || {}).events;
-      if (events && events.$destroy) {
-        nodes[i].dispatchEvent(new Event("$destroy"));
-      }
       removeElementData(nodes[i]);
     }
   }
@@ -1833,27 +1821,11 @@
       /** @type {!Array.<Function>} */
       this.runBlocks = [];
 
-      /** @type {Object} */
-      this.infoState = {};
-
       if (configFn) {
         this.config(configFn);
       }
     }
 
-    /**
-     * @param {Object} value
-     * @returns
-     */
-    info(value) {
-      if (isDefined(value)) {
-        assert(isObject(value), "module info value must be an object");
-        this.infoState = value;
-        return this;
-      }
-      return this.infoState;
-    }
-
     /**
      * @param {string} name
      * @param {any} object
@@ -2182,7 +2154,6 @@
 
   /**
    * Injector for providers
-   * @extends {AbstractInjector}
    */
   class ProviderInjector extends AbstractInjector {
     /**
@@ -2212,15 +2183,13 @@
 
   /**
    * Injector for factories and services
-   * @extends {AbstractInjector}
    */
   class InjectorService extends AbstractInjector {
     /**
-     *
-     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      * @param {ProviderInjector} providerInjector
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      */
-    constructor(strictDi, providerInjector) {
+    constructor(providerInjector, strictDi) {
       super(strictDi);
       this.providerInjector = providerInjector;
       this.modules = this.providerInjector.modules;
@@ -2358,7 +2327,7 @@
       strictDi,
     ));
 
-    const protoInstanceInjector = new InjectorService(strictDi, providerInjector);
+    const protoInstanceInjector = new InjectorService(providerInjector, strictDi);
 
     providerCache.$injectorProvider = {
       // $injectionProvider return instance injector
@@ -7582,7 +7551,9 @@
             }
 
             function triggerOnChangesHook() {
-              destination["$onChanges"] && destination["$onChanges"](changes);
+              destination["$onChanges"] &&
+                changes &&
+                destination["$onChanges"](changes);
               // Now clear the changes so that we schedule onChanges when more changes arrive
               changes = undefined;
             }
@@ -11566,8 +11537,6 @@
 
   ngIfDirective.$inject = ["$animate"];
   /**
-   *
-   * TODO // Add type for animate service
    * @param {*}  $animate
    * @returns {import("../../interface.ts").Directive}
    */
@@ -12209,7 +12178,7 @@
   function ngStyleDirective() {
     return {
       restrict: "A",
-      link: (scope, element, attr) => {
+      link(scope, element, attr) {
         let oldStyles;
         scope.$watch(attr["ngStyle"], (newStyles) => {
           if (oldStyles) {
@@ -14968,7 +14937,7 @@
    * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
    */
 
-  /** @typedef {import('../services/log').LogService} LogService */
+  /** @typedef {import('../services/log.js').LogService} LogService */
 
   /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 
@@ -19220,8 +19189,10 @@
       // http.timeout = promise             abort
       // xhr.abort()                        abort (The xhr object is normally inaccessible, but
       //                                    can be exposed with the xhrFactory)
+      /** @type {number} */
+      let timeoutId;
       if (timeout > 0) {
-        var timeoutId = setTimeout(() => {
+        timeoutId = setTimeout(() => {
           timeoutRequest("timeout");
         }, timeout);
       } else if (isPromiseLike(timeout)) {
@@ -26106,6 +26077,7 @@
     arr.push(val);
     return val;
   });
+
   /**
    * Applies a set of defaults to an options object.  The options object is filtered
    * to only those properties of the objects in the defaultsList.
@@ -26273,6 +26245,7 @@
    * ```
    */
   const unnest = (arr) => arr.reduce(unnestR, []);
+
   /**
    * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
    * @example
@@ -26287,6 +26260,7 @@
    * ```
    */
   const assertPredicate = assertFn;
+
   function assertFn(predicateOrMap, errMsg = "assert failure") {
     return (obj) => {
       const result = predicateOrMap(obj);
@@ -26367,10 +26341,17 @@
     memo[key] = value;
     return memo;
   }
-  /** Get the last element of an array */
+
+  /**
+   * Returns the last element of an array, or undefined if the array is empty.
+   * @template T
+   * @param {T[]} arr - The input array.
+   * @returns {T | undefined} The last element or undefined.
+   */
   function tail(arr) {
-    return (arr.length && arr[arr.length - 1]) || undefined;
+    return arr.length > 0 ? arr[arr.length - 1] : undefined;
   }
+
   /**
    * shallow copy from src to dest
    */
@@ -29003,10 +28984,10 @@
      * strings corresponding to native Object properties, e.g. "constructor",
      * "toString", "hasOwnProperty", etc.
      *
-     * @param {boolean=} opt_async Enable asynchronous behavior.  Recommended for
+     * @param {boolean=} async Enable asynchronous behavior.  Recommended for
      *     new code.  See notes on the publish() method.
      */
-    constructor(opt_async = false) {
+    constructor(async = false) {
       this.disposed = false;
 
       /**
@@ -29063,7 +29044,7 @@
       /**
        * @private @const {boolean}
        */
-      this.async_ = Boolean(opt_async);
+      this.async_ = Boolean(async);
     }
 
     /**
@@ -29147,9 +29128,9 @@
      * @param {Array} args Arguments to pass to the function.
      */
     static runAsync_(fn, context, args) {
-      setTimeout(() => {
+      Promise.resolve().then(() => {
         fn.apply(context, args);
-      }, 0);
+      });
     }
 
     /**
@@ -29215,7 +29196,7 @@
      * the order in which they were added, passing all arguments along.
      *
      * If this object was created with async=true, subscribed functions are called
-     * via setTimeout().  Otherwise, the functions are called directly, and if
+     * via Promise.resolve().  Otherwise, the functions are called directly, and if
      * any of them throw an uncaught error, publishing is aborted.
      *
      * @param {string} topic Topic to publish to.
@@ -35578,9 +35559,10 @@
     }
   }
 
+  ngChannelDirective.$inject = [$injectTokens.$eventBus];
   /**
    * Dynamically updates an element's content based on events published on a specified channel.
-   * If data is sent via `EventBus` on the specified `ngChannel`, the directive attempts to update the element's content accordingly,
+   * If data is sent via `$eventBus` on the specified `ngChannel`, the directive attempts to update the element's content accordingly,
    * either by directly setting the inner HTML or merging the scope's data if the element contains a template.
    *
    * If the element has a template and incoming data is an object, the directive will merge all key/value pairs onto the scope,
@@ -35593,17 +35575,18 @@
    * <div ng-channel="userChannel">Hello {{ user.firstName }} {{ user.lastName }}</div>
    *
    * JavaScript:
-   * angular.EventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
+   * angular.$eventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
    *
+   * @param {import("../../core/pubsub/pubsub.js").PubSub} $eventBus
    * @returns {import("../../interface.ts").Directive}
    */
-  function ngChannelDirective() {
+  function ngChannelDirective($eventBus) {
     return {
       link: (scope, element, attrs) => {
         const hasTemplate = element.childNodes.length > 0;
         const channel = attrs["ngChannel"];
 
-        const key = EventBus.subscribe(channel, async (val) => {
+        const key = $eventBus.subscribe(channel, (val) => {
           if (!hasTemplate) {
             element.innerHTML = val;
           } else {
@@ -35614,7 +35597,7 @@
         });
 
         scope.$on("$destroy", () => {
-          EventBus.unsubscribeByKey(key);
+          $eventBus.unsubscribeByKey(key);
         });
       },
     };
@@ -35682,16 +35665,252 @@
     };
   }
 
-  // @private
+  /**
+   * @param {"get" | "delete" | "post" | "put"} method
+   * @returns {import('../../interface.ts').DirectiveFactory}
+   */
+  function defineDirective(method) {
+    const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
+    const directive = createHttpDirective(method, attrName);
+    directive["$inject"] = ["$http", "$compile", "$log"];
+    return directive;
+  }
+
+  const ngGetDirective = defineDirective("get");
+  const ngDeleteDirective = defineDirective("delete");
+  const ngPostDirective = defineDirective("post");
+  const ngPutDirective = defineDirective("put");
+
+  /**
+   * Selects DOM event to listen for based on the element type.
+   *
+   * @param {Element} element - The DOM element to inspect.
+   * @returns {EventType} The name of the event to listen for.
+   */
+  function getEventNameForElement(element) {
+    const tag = element.tagName.toLowerCase();
+    if (["input", "textarea", "select"].includes(tag)) {
+      return "change";
+    } else if (tag === "form") {
+      return "submit";
+    }
+    return "click";
+  }
+
+  /**
+   * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
+   *
+   * @param {string} html - The HTML string returned from the server.
+   * @param {import("../../interface.ts").SwapInsertPosition} swap
+   * @param {Element} target - The target DOM element to apply the swap to.
+   * @param {import('../../core/scope/scope.js').Scope} scope
+   * @param {import('../../core/compile/compile.js').CompileFn} $compile
+   */
+  function handleSwapResponse(html, swap, target, scope, $compile) {
+    let nodes = [];
+    if (!["textcontent", "delete", "none"].includes(swap)) {
+      if (!html) {
+        return;
+      }
+
+      if (isObject(html)) {
+        scope.$merge(html);
+        return;
+      }
+
+      const compiled = $compile(html)(scope);
+      nodes =
+        compiled instanceof DocumentFragment
+          ? Array.from(compiled.childNodes)
+          : [compiled];
+    }
+
+    switch (swap) {
+      case "innerHTML":
+        target.replaceChildren(...nodes);
+        break;
+
+      case "outerHTML": {
+        const parent = target.parentNode;
+        if (!parent) return;
+        const frag = document.createDocumentFragment();
+        nodes.forEach((n) => frag.appendChild(n));
+        parent.replaceChild(frag, target);
+        break;
+      }
+
+      case "textContent":
+        target.textContent = html;
+        break;
+
+      case "beforebegin":
+        nodes.forEach((node) => target.parentNode.insertBefore(node, target));
+        break;
+
+      case "afterbegin":
+        nodes
+          .slice()
+          .reverse()
+          .forEach((node) => target.insertBefore(node, target.firstChild));
+        break;
+
+      case "beforeend":
+        nodes.forEach((node) => target.appendChild(node));
+        break;
+
+      case "afterend":
+        nodes
+          .slice()
+          .reverse()
+          .forEach((node) =>
+            target.parentNode.insertBefore(node, target.nextSibling),
+          );
+        break;
+
+      case "delete":
+        target.remove();
+        break;
+
+      case "none":
+        break;
+
+      default:
+        target.replaceChildren(...nodes);
+        break;
+    }
+  }
+
+  /**
+   * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
+   *
+   * @param {"get" | "delete" | "post" | "put"} method - HTTP method to use.
+   * @param {string} attrName - Attribute name containing the URL.
+   * @returns {import('../../interface.ts').DirectiveFactory}
+   */
+  function createHttpDirective(method, attrName) {
+    /**
+     * @param {{ [key: string]: Function }} $http
+     * @param {import("../../core/compile/compile.js").CompileFn} $compile
+     * @param {import("../../services/log.js").LogService} $log
+     * @returns {import('../../interface.ts').Directive}
+     */
+    return function ($http, $compile, $log) {
+      /**
+       * Collects form data from the element or its associated form.
+       *
+       * @param {HTMLElement} element
+       * @returns {Object<string, any>}
+       */
+      function collectFormData(element) {
+        /** @type {HTMLFormElement | null} */
+        let form = null;
+
+        const tag = element.tagName.toLowerCase();
+
+        if (tag === "form") {
+          /** @type {HTMLFormElement} */
+          form = /** @type {HTMLFormElement} */ (element);
+        } else if ("form" in element && element.form) {
+          /** @type {HTMLFormElement} */
+          form = /** @type {HTMLFormElement} */ (element.form);
+        } else if (element.hasAttribute("form")) {
+          const formId = element.getAttribute("form");
+          if (formId) {
+            /** @type {HTMLElement | null} */
+            const maybeForm = document.getElementById(formId);
+            if (maybeForm && maybeForm.tagName.toLowerCase() === "form") {
+              form = /** @type {HTMLFormElement} */ (maybeForm);
+            }
+          }
+        }
+
+        if (!form) {
+          if (
+            "name" in element &&
+            typeof element.name === "string" &&
+            element.name.length > 0
+          ) {
+            if (
+              element instanceof HTMLInputElement ||
+              element instanceof HTMLTextAreaElement ||
+              element instanceof HTMLSelectElement
+            ) {
+              const key = element.name;
+              const value = element.value;
+              return { [key]: value };
+            }
+          }
+          return {};
+        }
+
+        const formData = new FormData(form);
+        const data = {};
+        formData.forEach((value, key) => {
+          data[key] = value;
+        });
+        return data;
+      }
+
+      return {
+        restrict: "A",
+        terminal: true,
+        link(scope, element, attrs) {
+          /** @type {EventType} */
+          const eventName = getEventNameForElement(element);
+          const tag = element.tagName.toLowerCase();
+
+          element.addEventListener(eventName, (event) => {
+            if (/** @type {HTMLButtonElement} */ (element).disabled) return;
+            if (tag === "form") event.preventDefault();
+
+            const swap = element.dataset.swap || "innerHTML";
+            const targetSelector = element.dataset.target;
+            const target = targetSelector
+              ? document.querySelector(targetSelector)
+              : element;
+
+            if (!target) {
+              $log.warn(`${attrName}: target "${targetSelector}" not found`);
+              return;
+            }
+
+            const url = attrs[attrName];
+            if (!url) {
+              $log.warn(`${attrName}: no URL specified`);
+              return;
+            }
+
+            const handler = (res) => {
+              const html = res.data;
+              handleSwapResponse(
+                html,
+                /** @type {import("../../interface.ts").SwapInsertPosition} */ (
+                  swap
+                ),
+                target,
+                scope,
+                $compile,
+              );
+            };
 
-  const VERSION = "0.7.0";
+            if (method === "post" || method === "put") {
+              const data = collectFormData(element);
+              $http[method](url, data).then(handler).catch(handler);
+            } else {
+              $http[method](url).then(handler).catch(handler);
+            }
+          });
+        },
+      };
+    };
+  }
 
   /**
    * Initializes core `ng` module.
    * @param {import('./loader.js').Angular} angular
    * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
    */
-  function publishExternalAPI(angular) {
+  function registerNgModule(angular) {
     const ng = angular
       .module(
         "ng",
@@ -35721,8 +35940,10 @@
                 ngClassOdd: ngClassOddDirective,
                 ngCloak: ngCloakDirective,
                 ngController: ngControllerDirective,
+                ngDelete: ngDeleteDirective,
                 ngDisabled: ngDisabledAriaDirective,
                 ngForm: ngFormDirective,
+                ngGet: ngGetDirective,
                 ngHide: ngHideDirective,
                 ngIf: ngIfDirective,
                 ngInclude: ngIncludeDirective,
@@ -35733,6 +35954,8 @@
                 ngMessagesInclude: ngMessagesIncludeDirective,
                 ngMessageDefault: ngMessageDefaultDirective,
                 ngNonBindable: ngNonBindableDirective,
+                ngPost: ngPostDirective,
+                ngPut: ngPutDirective,
                 ngRef: ngRefDirective,
                 ngRepeat: ngRepeatDirective,
                 ngSetter: ngSetterDirective,
@@ -35837,8 +36060,7 @@
           return globals.params;
         },
       ])
-      .value("$trace", trace)
-      .info({ version: VERSION });
+      .value("$trace", trace);
 
     return ng;
   }
@@ -35860,16 +36082,16 @@
     constructor() {
       Cache.clear(); // a ensure new instance of angular gets a clean cache
 
-      /** @type {Map<number, import("./core/cache/cache").ExpandoStore>} */
-      this.Cache = Cache;
+      /** @type {Map<number, import("./core/cache/cache.js").ExpandoStore>} */
+      this.$cache = Cache;
 
       /** @type {import('./core/pubsub/pubsub.js').PubSub} */
-      this.EventBus = EventBus;
+      this.$eventBus = EventBus;
 
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = VERSION;
+      this.version = "0.7.3"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
@@ -35881,7 +36103,7 @@
 
       window["angular"] = this;
       this.$injectTokens = $injectTokens;
-      publishExternalAPI(this);
+      registerNgModule(this);
     }
 
     /**
@@ -36128,4 +36350,6 @@
     once: true,
   });
 
+  exports.angular = angular;
+
 }));