@angular-wave/angular.ts 0.14.0 → 0.14.1

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.14.0 - December 5, 2025 23:43:28 */
+/* Version: 0.14.1 - December 7, 2025 02:50:02 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -63,7 +63,6 @@
 
   const isProxySymbol = Symbol("isProxy");
   const BADARG = "badarg";
-  const BADARGKEY = "badarg: key";
   const BADARGVALUE = "badarg: value";
 
   /**
@@ -225,10 +224,7 @@
   }
 
   /**
-   * @module angular
-   * @function isDate
    *
-   * @description
    * Determines if a value is a date.
    *
    * @param {*} value Reference to check.
@@ -987,7 +983,7 @@
 
   /** @type {Map<ng.Validator, string>} */
   const reasons = new Map([
-    [isNullOrUndefined, "required"],
+    [notNullOrUndefined, "required"],
     [Array.isArray, "notarray"],
     [isInjectable, "notinjectable"],
     [isDefined, "required"],
@@ -1006,6 +1002,7 @@
   /**
    * Validate a value using a predicate function.
    * Throws if the predicate returns false.
+   * IMPORTANT: use this function only for developper errors and not for user/data errors
    *
    * @param {ng.Validator} fn - Predicate validator function.
    * @param {*} arg - The value to validate.
@@ -1047,6 +1044,16 @@
     return validate(Array.isArray, arg, name);
   }
 
+  /**
+   * @param {*} arg - The value to validate.
+   * @param {string} name - Parameter name (included in error message).
+   * @returns {*} The validated value.
+   * @throws {TypeError} If the value does not satisfy the validator.
+   */
+  function validateIsString(arg, name) {
+    return validate(isString, arg, name);
+  }
+
   /**
    * Throw error if the argument is falsy.
    */
@@ -1453,6 +1460,14 @@
     return { instance, exports: instance.exports, module };
   }
 
+  /**
+   * @param {*} fn
+   * @returns {boolean}
+   */
+  function isArrowFunction(fn) {
+    return typeof fn === "function" && !fn.prototype;
+  }
+
   /**
    * 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
@@ -2788,7 +2803,16 @@
       // Empty object at position 0 is ignored for invocation with `new`, but required.
       args.unshift(null);
 
-      return new (Function.prototype.bind.apply(ctor, args))();
+      try {
+        return new (Function.prototype.bind.apply(ctor, args))();
+      } catch (err) {
+        // try arrow function
+        if (isArrowFunction(ctor)) {
+          return ctor(args);
+        } else {
+          throw err;
+        }
+      }
     }
 
     /**
@@ -5381,6 +5405,8 @@
      * @returns {NgModule}
      */
     factory(name, providerFunction) {
+      validate(isString, name, "name");
+      validateRequired(providerFunction, "providerFunction");
       this.invokeQueue.push([$injectTokens.$provide, "factory", [name, providerFunction]]);
 
       return this;
@@ -5392,6 +5418,8 @@
      * @returns {NgModule}
      */
     service(name, serviceFunction) {
+      validate(isString, name, "name");
+      validateRequired(serviceFunction, "serviceFunction");
       this.services.push(name);
       this.invokeQueue.push([$injectTokens.$provide, "service", [name, serviceFunction]]);
 
@@ -5404,9 +5432,8 @@
      * @returns {NgModule}
      */
     provider(name, providerType) {
-      if (providerType && isFunction(providerType)) {
-        providerType.$$moduleName = name;
-      }
+      validate(isString, name, "name");
+      validateRequired(providerType, "providerType");
       this.invokeQueue.push([$injectTokens.$provide, "provider", [name, providerType]]);
 
       return this;
@@ -5418,9 +5445,8 @@
      * @returns {NgModule}
      */
     decorator(name, decorFn) {
-      if (decorFn && isFunction(decorFn)) {
-        decorFn.$$moduleName = name;
-      }
+      validate(isString, name, "name");
+      validateRequired(decorFn, "decorFn");
       this.configBlocks.push([$injectTokens.$provide, "decorator", [name, decorFn]]);
 
       return this;
@@ -5432,6 +5458,8 @@
      * @returns {NgModule}
      */
     directive(name, directiveFactory) {
+      validate(isString, name, "name");
+      validateRequired(directiveFactory, "directiveFactory");
       this.invokeQueue.push([
         $injectTokens.$compileProvider,
         "directive",
@@ -5447,6 +5475,8 @@
      * @returns {NgModule}
      */
     animation(name, animationFactory) {
+      validate(isString, name, "name");
+      validateRequired(animationFactory, "animationFactory");
       this.invokeQueue.push([
         $injectTokens.$animateProvider,
         "register",
@@ -5478,6 +5508,8 @@
      * @returns {NgModule}
      */
     controller(name, ctlFn) {
+      validate(isString, name, "name");
+      validateRequired(ctlFn, `fictlFnlterFn`);
       this.invokeQueue.push([$injectTokens.$controllerProvider, "register", [name, ctlFn]]);
 
       return this;
@@ -5505,6 +5537,8 @@
      * @returns {NgModule}
      */
     wasm(name, src, imports = {}, opts = {}) {
+      validate(isString, name, "name");
+      validate(isString, src, "src");
       const raw = !!opts.raw;
 
       this.invokeQueue.push([
@@ -5534,6 +5568,8 @@
      * @returns {NgModule}
      */
     worker(name, scriptPath, config) {
+      validate(isString, name, "name");
+      validate(isString, scriptPath, "scriptPath");
       this.invokeQueue.push([
         $injectTokens.$provide,
         "provider",
@@ -5550,16 +5586,18 @@
 
     /**
      * @param {string} name
-     * @param {Function} ctor
+     * @param {Function|Object} ctor - A regular function, an arrow function or an object
      * @param {ng.StorageType} type
      * @param {ng.StorageBackend} [backendOrConfig]
      * @returns {NgModule}
      */
     store(name, ctor, type, backendOrConfig) {
+      validate(isString, name, "name");
+      validateRequired(ctor, "ctor");
       this.invokeQueue.push([
         $injectTokens.$provide,
         "store",
-        [name, ctor, type, backendOrConfig],
+        [name, isObject(ctor) ? () => ctor : ctor, type, backendOrConfig],
       ]);
 
       return this;
@@ -5575,6 +5613,9 @@
      * @returns {NgModule}
      */
     rest(name, url, entityClass, options = {}) {
+      validate(isString, name, "name");
+      validate(isString, url, "url");
+      validate(isFunction, entityClass, "entityClass");
       const def = { name, url, entityClass, options };
 
       this.restDefinitions.push(def);
@@ -31780,357 +31821,179 @@
       this.eventBus = EventBus;
     }
 
-    /**
-     * @returns {PubSub}
-     */
-    $get = () => this.eventBus;
-  }
-
-  class PubSub {
-    static $nonscope;
-    /**
-     * Topic-based publish/subscribe channel.  Maintains a map of topics to
-     * subscriptions.  When a message is published to a topic, all functions
-     * subscribed to that topic are invoked in the order they were added.
-     * Uncaught errors abort publishing.
-     *
-     * Topics may be identified by any nonempty string, <strong>except</strong>
-     * strings corresponding to native Object properties, e.g. "constructor",
-     * "toString", "hasOwnProperty", etc.
-     *
-     * @param {boolean=} async Enable asynchronous behavior.  Recommended for
-     *     new code.  See notes on the publish() method.
-     */
-    constructor(async = false) {
-      this.disposed = false;
-
-      /**
-       * The next available subscription key.  Internally, this is an index into the
-       * sparse array of subscriptions.
-       *
-       * @private {number}
-       */
-      this.key = 1;
-
+    $get = [
+      $injectTokens.$exceptionHandler,
       /**
-       * Array of subscription keys pending removal once publishing is done.
-       *
-       * @private {!Array<number>}
-       * @const
+       * @param {ng.ExceptionHandlerService} $exceptionHandler
+       * @returns {PubSub}
        */
-      this.pendingKeys = [];
+      ($exceptionHandler) => {
+        this.$exceptionHandler = $exceptionHandler;
 
-      /**
-       * Lock to prevent the removal of subscriptions during publishing. Incremented
-       * at the beginning of {@link #publish}, and decremented at the end.
-       *
-       * @private {number}
-       */
-      this.publishDepth = 0;
+        return this.eventBus;
+      },
+    ];
+  }
 
-      /**
-       * Sparse array of subscriptions. Each subscription is represented by a tuple
-       * comprising a topic identifier, a function, and an optional context object.
-       * Each tuple occupies three consecutive positions in the array, with the
-       * topic identifier at index n, the function at index (n + 1), the context
-       * object at index (n + 2), the next topic at index (n + 3), etc. (This
-       * representation minimizes the number of object allocations and has been
-       * shown to be faster than an array of objects with three key-value pairs or
-       * three parallel arrays, especially on IE.) Once a subscription is removed
-       * via {@link unsubscribe} or {@link unsubscribeByKey}, the three
-       * corresponding array elements are deleted, and never reused. This means the
-       * total number of subscriptions during the lifetime of the pubsub channel is
-       * limited by the maximum length of a JavaScript array to (2^32 - 1) / 3 =
-       * 1,431,655,765 subscriptions, which should suffice for most applications.
-       *
-       * @private {!Array<?>}
-       * @const
-       */
-      this.subscriptions = [];
+  class PubSub {
+    constructor() {
+      /** @private {Object<string, Array<{fn: Function, context: any}>>} */
+      this._topics = Object.create(null);
 
-      /**
-       * Map of topics to arrays of subscription keys.
-       *
-       * @private {!Object<!Array<number>>}
-       */
-      this.topics = {};
+      /** @private */
+      this._disposed = false;
 
-      /**
-       * @private @const {boolean}
-       */
-      this.async_ = Boolean(async);
+      /** @type {ng.ExceptionHandlerService} */
+      this.$exceptionHandler = undefined;
     }
 
     /**
-     * Subscribes a function to a topic.  The function is invoked as a method on
-     * the given `opt_context` object, or in the global scope if no context
-     * is specified.  Subscribing the same function to the same topic multiple
-     * times will result in multiple function invocations while publishing.
-     * Returns a subscription key that can be used to unsubscribe the function from
-     * the topic via {@link unsubscribeByKey}.
-     *
-     * @param {string} topic Topic to subscribe to.
-     * @param {Function} fn Function to be invoked when a message is published to
-     *     the given topic.
-     * @param {Object=} opt_context Object in whose context the function is to be
-     *     called (the global scope if none).
-     * @return {number} Subscription key.
+     * Set instance to initial state
      */
-    subscribe(topic, fn, opt_context = null) {
-      let keys = this.topics[topic];
+    reset() {
+      /** @private {Object<string, Array<{fn: Function, context: any}>>} */
+      this._topics = Object.create(null);
 
-      if (!keys) {
-        // First subscription to this topic; initialize subscription key array.
-        keys = this.topics[topic] = [];
-      }
-
-      // Push the tuple representing the subscription onto the subscription array.
-      const { key } = this;
-
-      this.subscriptions[key] = topic;
-      this.subscriptions[key + 1] = fn;
-      this.subscriptions[key + 2] = opt_context;
-      this.key = key + 3;
-
-      // Push the subscription key onto the list of subscriptions for the topic.
-      keys.push(key);
-
-      // Return the subscription key.
-      return key;
+      /** @private */
+      this._disposed = false;
     }
 
     /**
-     * Subscribes a single-use function to a topic.  The function is invoked as a
-     * method on the given `opt_context` object, or in the global scope if
-     * no context is specified, and is then unsubscribed.  Returns a subscription
-     * key that can be used to unsubscribe the function from the topic via
-     * {@link unsubscribeByKey}.
-     *
-     * @param {string} topic Topic to subscribe to.
-     * @param {Function} fn Function to be invoked once and then unsubscribed when
-     *     a message is published to the given topic.
-     * @param {Object=} opt_context Object in whose context the function is to be
-     *     called (the global scope if none).
-     * @return {number} Subscription key.
+     * Checks if instance has been disposed.
+     * @returns {boolean} True if disposed.
      */
-    subscribeOnce(topic, fn, opt_context = null) {
-      let called = false;
-
-      // Behold the power of lexical closures!
-      const key = this.subscribe(
-        topic,
-        (...args) => {
-          if (!called) {
-            called = true;
-
-            // Unsubscribe before calling function so the function is unsubscribed
-            // even if it throws an exception.
-            this.unsubscribeByKey(key);
-
-            fn.apply(opt_context, args);
-          }
-        },
-        this,
-      );
-
-      return key;
+    isDisposed() {
+      return this._disposed;
     }
 
     /**
-     * Runs a function asynchronously.
-     *
-     * @private
-     * @param {Function} fn Function to run.
-     * @param {Object} context Context in which to run the function.
-     * @param {Array} args Arguments to pass to the function.
+     * Dispose the instance, removing all topics and listeners.
      */
-    static runAsync_(fn, context, args) {
-      queueMicrotask(() => {
-        fn.apply(context, args);
-      });
+    dispose() {
+      if (this._disposed) return;
+      this._disposed = true;
+      this._topics = Object.create(null);
     }
 
     /**
-     * Unsubscribes a function from a topic.  Only deletes the first match found.
-     * Returns a Boolean indicating whether a subscription was removed.
-     *
-     * @param {string} topic Topic to unsubscribe from.
-     * @param {Function} fn Function to unsubscribe.
-     * @param {Object=} opt_context Object in whose context the function was to be
-     *     called (the global scope if none).
-     * @return {boolean} Whether a matching subscription was removed.
+     * Subscribe a function to a topic.
+     * @param {string} topic - The topic to subscribe to.
+     * @param {Function} fn - The callback function to invoke when published.
+     * @param {*} [context] - Optional `this` context for the callback.
+     * @returns {() => boolean} A function that unsubscribes this listener.
      */
-    unsubscribe(topic, fn, opt_context = null) {
-      const keys = this.topics[topic];
+    subscribe(topic, fn, context = undefined) {
+      if (this._disposed) return () => false;
 
-      if (keys) {
-        const { subscriptions } = this;
+      /** @type {Array<{fn: Function, context: any}>} */
+      let listeners = this._topics[topic];
 
-        const key = keys.find(
-          (k) =>
-            subscriptions[k + 1] === fn && subscriptions[k + 2] === opt_context,
-        );
+      if (!listeners) this._topics[topic] = listeners = [];
 
-        if (key !== undefined) {
-          return this.unsubscribeByKey(key);
-        }
-      }
+      const entry = { fn, context };
 
-      return false;
+      listeners.push(entry);
+
+      return () => this.unsubscribe(topic, fn, context);
     }
 
     /**
-     * Removes a subscription based on the key returned by {@link subscribe}.
-     * No-op if no matching subscription is found.  Returns a Boolean indicating
-     * whether a subscription was removed.
-     *
-     * @param {number} key Subscription key.
-     * @return {boolean} Whether a matching subscription was removed.
+     * Subscribe a function to a topic only once.
+     * Listener is removed before the first invocation.
+     * @param {string} topic - The topic to subscribe to.
+     * @param {Function} fn - The callback function.
+     * @param {*} [context] - Optional `this` context for the callback.
+     * @returns {() => boolean} A function that unsubscribes this listener.
      */
-    unsubscribeByKey(key) {
-      const topic = this.subscriptions[key];
+    subscribeOnce(topic, fn, context = undefined) {
+      if (this._disposed) return () => false;
 
-      if (topic) {
-        const keys = this.topics[topic];
+      let called = false;
 
-        if (this.publishDepth !== 0) {
-          // Defer removal until after publishing is complete, but replace the
-          // function with a no-op so it isn't called.
-          this.pendingKeys.push(key);
-          this.subscriptions[key + 1] = () => {
-            /* empty */
-          };
-        } else {
-          if (keys) {
-            this.topics[topic] = keys.filter((k) => k !== key);
-          }
-          delete this.subscriptions[key];
-          delete this.subscriptions[key + 1];
-          delete this.subscriptions[key + 2];
-        }
-      }
+      const wrapper = (...args) => {
+        if (called) return;
+        called = true;
+
+        unsub(); // unsubscribe before running
+        fn.apply(context, args);
+      };
 
-      return !!topic;
+      const unsub = this.subscribe(topic, wrapper);
+
+      return unsub;
     }
 
     /**
-     * Publishes a message to a topic.  Calls functions subscribed to the topic in
-     * the order in which they were added, passing all arguments along.
-     *
-     * If this object was created with async=true, subscribed functions are called
-     * via `queueMicrotask`.  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.
-     * @param {...*} var_args Arguments that are applied to each subscription
-     *     function.
-     * @return {boolean} Whether any subscriptions were called.
+     * Unsubscribe a specific function from a topic.
+     * Matches by function reference and optional context.
+     * @param {string} topic - The topic to unsubscribe from.
+     * @param {Function} fn - The listener function.
+     * @param {*} [context] - Optional `this` context.
+     * @returns {boolean} True if the listener was found and removed.
      */
-    publish(topic, ...var_args) {
-      const keys = this.topics[topic];
+    unsubscribe(topic, fn, context = undefined) {
+      if (this._disposed) return false;
 
-      if (keys) {
-        const args = var_args;
+      const listeners = this._topics[topic];
 
-        if (this.async_) {
-          // For each key in the list of subscription keys for the topic, schedule
-          // the function to be applied to the arguments in the appropriate context.
-          for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
+      if (!listeners || listeners.length === 0) return false;
 
-            PubSub.runAsync_(
-              this.subscriptions[key + 1],
-              this.subscriptions[key + 2],
-              args,
-            );
-          }
-        } else {
-          this.publishDepth++;
-
-          try {
-            for (
-              let i = 0, len = keys.length;
-              i < len && !this.isDisposed();
-              i++
-            ) {
-              const key = keys[i];
-
-              this.subscriptions[key + 1].apply(
-                this.subscriptions[key + 2],
-                args,
-              );
-            }
-          } finally {
-            this.publishDepth--;
+      for (let i = 0; i < listeners.length; i++) {
+        const l = listeners[i];
 
-            if (this.pendingKeys.length > 0 && this.publishDepth === 0) {
-              let pendingKey;
+        if (l.fn === fn && l.context === context) {
+          listeners.splice(i, 1);
 
-              while ((pendingKey = this.pendingKeys.pop())) {
-                this.unsubscribeByKey(pendingKey);
-              }
-            }
-          }
+          return true;
         }
-
-        return true;
       }
 
       return false;
     }
 
     /**
-     * Clears the subscription list for a topic, or all topics if unspecified.
-     * @param {string=} opt_topic Topic to clear (all topics if unspecified).
+     * Get the number of subscribers for a topic.
+     * @param {string} topic
+     * @returns {number}
      */
-    clear(opt_topic) {
-      if (opt_topic) {
-        const keys = this.topics[opt_topic];
+    getCount(topic) {
+      const listeners = this._topics[topic];
 
-        if (keys) {
-          keys.forEach(this.unsubscribeByKey, this);
-          delete this.topics[opt_topic];
-        }
-      } else {
-        this.subscriptions.length = 0;
-        this.topics = {};
-      }
+      return listeners ? listeners.length : 0;
     }
 
     /**
-     * Returns the number of subscriptions to the given topic (or all topics if
-     * unspecified). This number will not change while publishing any messages.
-     * @param {string=} opt_topic The topic (all topics if unspecified).
-     * @return {number} Number of subscriptions to the topic.
+     * Publish a value to a topic asynchronously.
+     * All listeners are invoked in the order they were added.
+     * @param {string} topic - The topic to publish.
+     * @param {...*} args - Arguments to pass to listeners.
+     * @returns {boolean} True if any listeners exist for this topic.
      */
-    getCount(opt_topic) {
-      if (opt_topic) {
-        const keys = this.topics[opt_topic];
+    publish(topic, ...args) {
+      if (this._disposed) return false;
 
-        return keys ? keys.length : 0;
-      }
+      const listeners = this._topics[topic];
 
-      let count = 0;
+      if (!listeners || listeners.length === 0) return false;
 
-      for (const topic in this.topics) {
-        count += this.getCount(topic);
-      }
-
-      return count;
-    }
+      // snapshot to prevent modifications during publish from affecting this call
+      const snapshot = listeners.slice();
 
-    isDisposed() {
-      return this.disposed;
-    }
+      queueMicrotask(() => {
+        for (const { fn, context } of snapshot) {
+          try {
+            fn.apply(context, args);
+          } catch (err) {
+            this.$exceptionHandler(err);
+          }
+        }
+      });
 
-    dispose() {
-      this.clear();
-      this.pendingKeys.length = 0;
-      this.disposed = true;
+      return true;
     }
   }
 
-  const EventBus = new PubSub(true);
+  const EventBus = new PubSub();
 
   const defaultOptions = {
     current: () => {
@@ -39166,7 +39029,7 @@
 
         const hasTemplateContent = element.childNodes.length > 0;
 
-        const key = $eventBus.subscribe(channel, (value) => {
+        const unsubscribe = $eventBus.subscribe(channel, (value) => {
           if (hasTemplateContent) {
             if (isObject(value)) {
               scope.$merge(value);
@@ -39176,9 +39039,7 @@
           }
         });
 
-        scope.$on("$destroy", () => {
-          $eventBus.unsubscribeByKey(key);
-        });
+        scope.$on("$destroy", () => unsubscribe());
       },
     };
   }
@@ -39573,8 +39434,6 @@
      * @param {ng.ExceptionHandlerService} $exceptionHandler
      */
     constructor(defaults, $exceptionHandler) {
-      assert(isObject(defaults), BADARG);
-      assert(isFunction($exceptionHandler), BADARG);
       /** @type {ng.CookieOptions} */
       this.defaults = Object.freeze({ ...defaults });
       this.$exceptionHandler = $exceptionHandler;
@@ -39588,7 +39447,7 @@
      * @throws {URIError} – If decodeURIComponent fails.
      */
     get(key) {
-      assert(isString(key), BADARG);
+      validateIsString(key, "key");
 
       try {
         const all = parseCookies();
@@ -39608,7 +39467,8 @@
      * @throws {SyntaxError} if cookie JSON is invalid
      */
     getObject(key) {
-      assert(isString(key), BADARG);
+      validateIsString(key, "key");
+
       const raw = this.get(key);
 
       if (!raw) return null;
@@ -39644,8 +39504,8 @@
      * @param {ng.CookieOptions} [options]
      */
     put(key, value, options = {}) {
-      assert(isString(key), BADARGKEY);
-      assert(isString(value), BADARGVALUE);
+      validateIsString(key, "key");
+      validateIsString(value, "value");
       const encodedKey = encodeURIComponent(key);
 
       const encodedVal = encodeURIComponent(value);
@@ -39669,7 +39529,8 @@
      * @throws {TypeError} if Object cannot be converted to JSON
      */
     putObject(key, value, options) {
-      assert(isString(key), BADARGKEY);
+      validateIsString(key, "key");
+      validateRequired(value, "value");
       assert(!isNullOrUndefined(value), BADARGVALUE);
 
       try {
@@ -39690,7 +39551,7 @@
      * @param {ng.CookieOptions} [options]
      */
     remove(key, options = {}) {
-      assert(isString(key), BADARG);
+      validateIsString(key, "key");
       this.put(key, "", {
         ...this.defaults,
         ...options,
@@ -40507,7 +40368,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.14.0"; //inserted via rollup plugin
+      this.version = "0.14.1"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];