@angular-wave/angular.ts 0.14.0 → 0.14.2

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.14.0 - December 5, 2025 23:43:29 */
+/* Version: 0.14.2 - December 7, 2025 03:52:37 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -57,7 +57,6 @@ function isPromise(obj) {
 
 const isProxySymbol = Symbol("isProxy");
 const BADARG = "badarg";
-const BADARGKEY = "badarg: key";
 const BADARGVALUE = "badarg: value";
 
 /**
@@ -219,10 +218,7 @@ function isNumber(value) {
 }
 
 /**
- * @module angular
- * @function isDate
  *
- * @description
  * Determines if a value is a date.
  *
  * @param {*} value Reference to check.
@@ -981,7 +977,7 @@ function assert(argument, errorMsg = "Assertion failed") {
 
 /** @type {Map<ng.Validator, string>} */
 const reasons = new Map([
-  [isNullOrUndefined, "required"],
+  [notNullOrUndefined, "required"],
   [Array.isArray, "notarray"],
   [isInjectable, "notinjectable"],
   [isDefined, "required"],
@@ -1000,6 +996,7 @@ function getReason(val) {
 /**
  * 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.
@@ -1041,6 +1038,16 @@ function validateArray(arg, name) {
   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.
  */
@@ -1447,6 +1454,14 @@ async function instantiateWasm(src, imports = {}) {
   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
@@ -2782,7 +2797,16 @@ class AbstractInjector {
     // 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;
+      }
+    }
   }
 
   /**
@@ -5375,6 +5399,8 @@ class NgModule {
    * @returns {NgModule}
    */
   factory(name, providerFunction) {
+    validate(isString, name, "name");
+    validateRequired(providerFunction, "providerFunction");
     this.invokeQueue.push([$injectTokens.$provide, "factory", [name, providerFunction]]);
 
     return this;
@@ -5386,6 +5412,8 @@ class NgModule {
    * @returns {NgModule}
    */
   service(name, serviceFunction) {
+    validate(isString, name, "name");
+    validateRequired(serviceFunction, "serviceFunction");
     this.services.push(name);
     this.invokeQueue.push([$injectTokens.$provide, "service", [name, serviceFunction]]);
 
@@ -5398,9 +5426,8 @@ class NgModule {
    * @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;
@@ -5412,9 +5439,8 @@ class NgModule {
    * @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;
@@ -5426,6 +5452,8 @@ class NgModule {
    * @returns {NgModule}
    */
   directive(name, directiveFactory) {
+    validate(isString, name, "name");
+    validateRequired(directiveFactory, "directiveFactory");
     this.invokeQueue.push([
       $injectTokens.$compileProvider,
       "directive",
@@ -5441,6 +5469,8 @@ class NgModule {
    * @returns {NgModule}
    */
   animation(name, animationFactory) {
+    validate(isString, name, "name");
+    validateRequired(animationFactory, "animationFactory");
     this.invokeQueue.push([
       $injectTokens.$animateProvider,
       "register",
@@ -5472,6 +5502,8 @@ class NgModule {
    * @returns {NgModule}
    */
   controller(name, ctlFn) {
+    validate(isString, name, "name");
+    validateRequired(ctlFn, `fictlFnlterFn`);
     this.invokeQueue.push([$injectTokens.$controllerProvider, "register", [name, ctlFn]]);
 
     return this;
@@ -5499,6 +5531,8 @@ class NgModule {
    * @returns {NgModule}
    */
   wasm(name, src, imports = {}, opts = {}) {
+    validate(isString, name, "name");
+    validate(isString, src, "src");
     const raw = !!opts.raw;
 
     this.invokeQueue.push([
@@ -5528,6 +5562,8 @@ class NgModule {
    * @returns {NgModule}
    */
   worker(name, scriptPath, config) {
+    validate(isString, name, "name");
+    validate(isString, scriptPath, "scriptPath");
     this.invokeQueue.push([
       $injectTokens.$provide,
       "provider",
@@ -5544,16 +5580,18 @@ class NgModule {
 
   /**
    * @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;
@@ -5569,6 +5607,9 @@ class NgModule {
    * @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);
@@ -31774,357 +31815,179 @@ class PubSubProvider {
     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: () => {
@@ -39160,7 +39023,7 @@ function ngChannelDirective($eventBus) {
 
       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);
@@ -39170,9 +39033,7 @@ function ngChannelDirective($eventBus) {
         }
       });
 
-      scope.$on("$destroy", () => {
-        $eventBus.unsubscribeByKey(key);
-      });
+      scope.$on("$destroy", () => unsubscribe());
     },
   };
 }
@@ -39567,8 +39428,6 @@ class CookieService {
    * @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;
@@ -39582,7 +39441,7 @@ class CookieService {
    * @throws {URIError} – If decodeURIComponent fails.
    */
   get(key) {
-    assert(isString(key), BADARG);
+    validateIsString(key, "key");
 
     try {
       const all = parseCookies();
@@ -39602,7 +39461,8 @@ class CookieService {
    * @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;
@@ -39638,8 +39498,8 @@ class CookieService {
    * @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);
@@ -39663,7 +39523,8 @@ class CookieService {
    * @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 {
@@ -39684,7 +39545,7 @@ class CookieService {
    * @param {ng.CookieOptions} [options]
    */
   remove(key, options = {}) {
-    assert(isString(key), BADARG);
+    validateIsString(key, "key");
     this.put(key, "", {
       ...this.defaults,
       ...options,
@@ -40501,7 +40362,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.14.0"; //inserted via rollup plugin
+    this.version = "0.14.2"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];