@angular-wave/angular.ts 0.7.3 → 0.7.4

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.7.3 - July 4, 2025 23:40:50 */
+/* Version: 0.7.4 - July 11, 2025 03:03:25 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1136,36 +1136,29 @@
     return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
-  /**
-   * @typedef {Object} ExpandoStore
-   * @property {!Object<string, any>} data
-   *
-   */
-
-  const EXPANDO = "ng";
-
   /**
    * 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
    * for performance reasons and convenience methods. A proxy is available for
    * additional logic handling.
    *
-   * @type {Map<number, ExpandoStore>}
+   * @type {Map<number, import('../interface.ts').ExpandoStore>}
    */
   const Cache = new Map();
 
-  /**
-   * Key for storing scope data, attached to an element
-   */
-  const SCOPE_KEY = "$scope";
+  /** @type {number} */
+  let jqId = 1;
 
   /**
    * Key for storing isolate scope data, attached to an element
    */
   const ISOLATE_SCOPE_KEY = "$isolateScope";
+  const EXPANDO = "ng";
 
-  /** @type {number} */
-  let jqId = 1;
+  /**
+   * Key for storing scope data, attached to an element
+   */
+  const SCOPE_KEY = "$scope";
 
   const DASH_LOWERCASE_REGEXP = /-([a-z])/g;
   const UNDERSCORE_LOWERCASE_REGEXP = /_([a-z])/g;
@@ -1266,7 +1259,7 @@
    *
    * @param {Element} element
    * @param {boolean} [createIfNecessary=false]
-   * @returns {import("../core/cache/cache.js").ExpandoStore}
+   * @returns {import("../interface.ts").ExpandoStore}
    */
   function getExpando(element, createIfNecessary = false) {
     let expandoId = element[EXPANDO];
@@ -1711,6 +1704,9 @@
    *   angular.$injectTokens.$animate,
    *   angular.$injectTokens.$templateRequest,
    * ];
+   *
+   * function myDirective($animate, $templateRequest) { ... }
+   *
    * ```
    * @type Readonly<Record<string, string>>
    */
@@ -10621,7 +10617,7 @@
   scriptDirective.$inject = ["$templateCache"];
 
   /**
-   * @param {import('../../core/cache/cache-factory').TemplateCache} $templateCache
+   * @param {import('../../services/template-cache/interface.ts').TemplateCache} $templateCache
    * @returns {import('../../interface.ts').Directive}
    */
   function scriptDirective($templateCache) {
@@ -11282,6 +11278,8 @@
   }
 
   /**
+   * @param {string} name
+   * @param {boolean|number} selector
    * @returns {() => import("../../interface.ts").Directive}
    */
   function classDirective(name, selector) {
@@ -11297,6 +11295,7 @@
         link(scope, element, attr) {
           let classCounts = getCacheData(element, "$classCounts");
           let oldModulo = true;
+          /** @type {string|undefined} */
           let oldClassString;
 
           if (!classCounts) {
@@ -11315,6 +11314,9 @@
             ngClassWatchAction(toClassString(val));
           });
 
+          /**
+           * @param {string} classString
+           */
           function addClasses(classString) {
             classString = digestClassCounts(split(classString), 1);
             if (hasAnimate(element)) {
@@ -11328,6 +11330,9 @@
             }
           }
 
+          /**
+           * @param {string} classString
+           */
           function removeClasses(classString) {
             classString = digestClassCounts(split(classString), -1);
             if (hasAnimate(element)) {
@@ -11341,6 +11346,10 @@
             }
           }
 
+          /**
+           * @param {string} oldClassString
+           * @param {string} newClassString
+           */
           function updateClasses(oldClassString, newClassString) {
             const oldClassArray = split(oldClassString);
             const newClassArray = split(newClassString);
@@ -11391,6 +11400,9 @@
             oldModulo = newModulo;
           }
 
+          /**
+           * @param {string} newClassString
+           */
           function ngClassWatchAction(newClassString) {
             if (oldModulo === selector) {
               updateClasses(oldClassString, newClassString);
@@ -14874,23 +14886,17 @@
   }
 
   /**
-   * A cache for maping template names to their respective content.
-   *
-   * @typedef {Map<string, string>} TemplateCache
-   */
-
-  /**
-   * Service responsible for providing a cache for templates.
-   *
-   * @class TemplateCacheProvider
-   * @description Provides an instance of a template cache that can be used to store and retrieve template content.
+   * Provides an instance of a cache that can be used to store and retrieve template content.
    */
   class TemplateCacheProvider {
+    constructor() {
+      /** @type {import('./interface.ts').TemplateCache} */
+      this.cache = new Map();
+    }
     /**
-     * @description Returns a new instance of a `TemplateCache`, which is a Map used to store templates.
-     * @returns {TemplateCache} A new instance of the template cache (Map object).
+     * @returns {import('./interface.ts').TemplateCache}
      */
-    $get = () => new Map();
+    $get = () => this.cache;
   }
 
   /**
@@ -14937,7 +14943,7 @@
    * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
    */
 
-  /** @typedef {import('../services/log.js').LogService} LogService */
+  /** @typedef {import('../services/log/interface.ts').LogService} LogService */
 
   /** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 
@@ -18503,8 +18509,8 @@
        *
        * @param {*} $browser
        * @param {*} $httpBackend
-       * @param {*} $rootScope
-       * @param {import("../../core/di/internal-injector").InjectorService} $injector
+       * @param {import("../../core/scope/scope.js").Scope} $rootScope
+       * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
@@ -18942,9 +18948,9 @@
               Object.entries(eventHandlers).forEach(([key, eventHandler]) => {
                 applyHandlers[key] = function (event) {
                   if (useApplyAsync) {
-                    setTimeout(() => $rootScope.$apply(callEventHandler));
+                    setTimeout(() => callEventHandler());
                   } else {
-                    $rootScope.$apply(callEventHandler);
+                    callEventHandler();
                   }
 
                   function callEventHandler() {
@@ -19052,17 +19058,27 @@
    * {@link ng.$http $http}.
    *
    */
-  function HttpBackendProvider() {
-    this.$get = [
-      "$browser",
-      /**
-       * @param {import('../browser.js').Browser} $browser
-       * @returns
-       */
-      function ($browser) {
-        return createHttpBackend($browser);
-      },
-    ];
+  /**
+   * HTTP backend used by the {@link ng.$http service} that delegates to
+   * XMLHttpRequest object and deals with browser incompatibilities.
+   *
+   * You should never need to use this service directly, instead use the higher-level abstractions:
+   * {@link ng.$http $http}.
+   *
+   */
+  class HttpBackendProvider {
+    constructor() {
+      this.$get = [
+        "$browser",
+        /**
+         * @param {import('../browser.js').Browser} $browser
+         * @returns
+         */
+        function ($browser) {
+          return createHttpBackend($browser);
+        },
+      ];
+    }
   }
 
   /**
@@ -20196,57 +20212,27 @@
     return a === b || urlResolve(a).href === urlResolve(b).href;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // LogService
-  // see http://docs.angularjs.org/api/ng/service/$log
-  // see http://docs.angularjs.org/api/ng/provider/$logProvider
-  ///////////////////////////////////////////////////////////////////////////
-
   /**
-   * @typedef {(...args: any[]) => void} LogCall
-   */
-
-  /**
-   * @typedef {Object} LogService
-   * @property {LogCall} debug - Log a debug messages
-   * @property {LogCall} error - Log a error message
-   * @property {LogCall} info - Log a info message
-   * @property {LogCall} log - Log a general message
-   * @property {LogCall} warn - Log a warning message
-   */
-
-  /**
-   * @type {LogService}
-   */
-  let LogService = {
-    debug: undefined,
-    error: undefined,
-    info: undefined,
-    log: undefined,
-    warn: undefined,
-  };
-
-  /**
-   * @type {LogProvider}
-   * Use the `$logProvider` to configure how the application logs messages
+   * Configuration provider for `$log` service
    */
   class LogProvider {
+    /** @private */
     constructor() {
-      this.debug = true;
+      /** @type {boolean} */
+      this.debug = false;
+      /** @private @type {import("./interface.ts").LogServiceFactory | null} */
+      this._override = null;
     }
 
     /**
-     * @param {boolean=} flag enable or disable debug level messages
-     * @returns {*} current value if used as getter or itself (chaining) if used as setter
+     * Override the default {@link LogService} implemenation
+     * @param {import("./interface.ts").LogServiceFactory} fn
      */
-    debugEnabled(flag) {
-      if (typeof flag !== "undefined") {
-        this.debug = flag;
-        return this;
-      }
-      return this.debug;
+    setLogger(fn) {
+      this._override = fn;
     }
 
+    /** @private */
     formatError(arg) {
       if (isError(arg)) {
         if (arg.stack) {
@@ -20261,6 +20247,10 @@
       return arg;
     }
 
+    /**
+     * @private
+     * @param {string} type
+     */
     consoleLog(type) {
       const console = window.console || {};
       const logFn = console[type] || console.log || (() => {});
@@ -20271,8 +20261,14 @@
       };
     }
 
+    /**
+     * @returns {import("./interface.ts").LogService}
+     */
     $get() {
-      LogService = {
+      if (this._override) {
+        return this._override();
+      }
+      return {
         log: this.consoleLog("log"),
         info: this.consoleLog("info"),
         warn: this.consoleLog("warn"),
@@ -20286,7 +20282,6 @@
           };
         })(),
       };
-      return LogService;
     }
   }
 
@@ -21541,7 +21536,7 @@
       /**
        * Creates a new `TaskTracker` instance.
        *
-       * @param {import('../services/log.js').LogService} log - The logging service.
+       * @param {import('../services/log/interface.ts').LogService} log - The logging service.
        * @returns {TaskTracker} A new `TaskTracker` instance.
        */
       (log) => new TaskTracker(log),
@@ -21556,7 +21551,7 @@
    */
   class TaskTracker {
     /**
-     * @param {import('../services/log.js').LogService} log - The logging service.
+     * @param {import('../services/log/interface.ts').LogService} log - The logging service.
      */
     constructor(log) {
       /** @private */
@@ -21734,8 +21729,8 @@
       /**
        *
        * @param {import('../core/exception-handler.js').ErrorHandler} $exceptionHandler
-       * @param {import('../core/cache/cache-factory.js').TemplateCache} $templateCache
-       * @param {*} $http
+       * @param {import('../services/template-cache/interface.ts').TemplateCache} $templateCache
+       * @param {import("interface.ts").HttpService} $http
        * @param {*} $sce
        * @returns
        */
@@ -27666,12 +27661,15 @@
       Object.prototype.hasOwnProperty.bind(cfg || {}),
     ).length === 0;
 
-  let DefType;
-  (function (DefType) {
-    DefType[(DefType["PATH"] = 0)] = "PATH";
-    DefType[(DefType["SEARCH"] = 1)] = "SEARCH";
-    DefType[(DefType["CONFIG"] = 2)] = "CONFIG";
-  })(DefType || (DefType = {}));
+  /**
+   * @private
+   * @enum {number}
+   */
+  const DefType = {
+    PATH: 0,
+    SEARCH: 1,
+    CONFIG: 2,
+  };
 
   function getParamDeclaration(paramName, location, state) {
     const noReloadOnSearch =
@@ -27684,6 +27682,7 @@
     );
     return Object.assign(defaultConfig, paramConfig);
   }
+
   function unwrapShorthand(cfg) {
     cfg = isShorthand(cfg) ? { value: cfg } : cfg;
     getStaticDefaultValue["__cacheable"] = true;
@@ -27693,6 +27692,7 @@
     const $$fn = isInjectable(cfg.value) ? cfg.value : getStaticDefaultValue;
     return Object.assign(cfg, { $$fn });
   }
+
   function getType(cfg, urlType, location, id, paramTypes) {
     if (cfg.type && urlType && urlType.name !== "string")
       throw new Error(`Param '${id}' has two type configurations.`);
@@ -27717,6 +27717,7 @@
     }
     return cfg.type instanceof ParamType ? cfg.type : paramTypes.type(cfg.type);
   }
+
   /** returns false, true, or the squash value to indicate the "default parameter url squash policy". */
   function getSquashPolicy(config, isOptional, defaultPolicy) {
     const squash = config.squash;
@@ -27727,6 +27728,7 @@
       `Invalid squash policy: '${squash}'. Valid policies: false, true, or arbitrary string`,
     );
   }
+
   function getReplace(config, arrayMode, isOptional, squash) {
     const defaultPolicy = [
       { from: "", to: isOptional || arrayMode ? undefined : "" },
@@ -27740,7 +27742,16 @@
       (item) => configuredKeys.indexOf(item.from) === -1,
     ).concat(replace);
   }
+
   class Param {
+    /**
+     *
+     * @param {*} id
+     * @param {*} type
+     * @param {DefType} location
+     * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
+     * @param {*} state
+     */
     constructor(id, type, location, urlConfig, state) {
       const config = getParamDeclaration(id, location, state);
       type = getType(config, type, location, id, urlConfig.paramTypes);
@@ -28957,9 +28968,10 @@
 
   /**
    * Configurable provider for an injectable event bus
-   * @implements {ServiceProvider}
+   * @extends {ServiceProvider}
    */
   class PubSubProvider {
+    /** @private */
     constructor() {
       /**
        * @type {PubSub}
@@ -29023,7 +29035,7 @@
        * 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
+       * 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 =
@@ -29053,7 +29065,7 @@
      * 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}.
+     * 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
@@ -29088,7 +29100,7 @@
      * 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}.
+     * {@link unsubscribeByKey}.
      *
      * @param {string} topic Topic to subscribe to.
      * @param {Function} fn Function to be invoked once and then unsubscribed when
@@ -29161,7 +29173,7 @@
     }
 
     /**
-     * Removes a subscription based on the key returned by {@link #subscribe}.
+     * 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.
      *
@@ -32067,8 +32079,8 @@
       "$templateRequest",
       "$injector",
       /**
-       * @param {any} $http
-       * @param {import("../core/cache/cache-factory.js").TemplateCache} $templateCache
+       * @param {import("interface.ts").HttpService} $http
+       * @param {import("../services/template-cache/interface.ts").TemplateCache} $templateCache
        * @param {any} $templateRequest
        * @param {import("../core/di/internal-injector.js").InjectorService} $injector
        * @returns
@@ -32167,7 +32179,7 @@
       if (url == null) return null;
       if (this._useHttp) {
         return this.$http
-          .get(url, {
+          .get(/** @type {string} */ (url), {
             cache: this.$templateCache,
             headers: { Accept: "text/html" },
           })
@@ -33479,7 +33491,13 @@
   }
 
   class ParamFactory {
+    /**
+     * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
+     */
     constructor(urlServiceConfig) {
+      /**
+       * @type {import("../url/url-config.js").UrlConfigProvider}
+       */
       this.urlServiceConfig = urlServiceConfig;
     }
 
@@ -33533,7 +33551,7 @@
        * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
        *
        * See: [[UrlConfig]] for details
-       * @type {import("./url-config").UrlConfigProvider}
+       * @type {import("./url-config.js").UrlConfigProvider}
        */
       this.config = urlConfigProvider;
 
@@ -34048,6 +34066,9 @@
     };
   }
 
+  /**
+   * @param {import("../params/param-factory.js").ParamFactory} paramFactory
+   */
   function getParamsBuilder(paramFactory) {
     return function (state) {
       const makeConfigParam = (_config, id) =>
@@ -35561,38 +35582,22 @@
 
   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,
-   * 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,
-   * allowing Angular expressions (`{{ yourModel }}`) to be evaluated and rendered.
-   *
-   * When the scope is destroyed, the directive automatically unsubscribes from the channel.
-   * Example:
-   *
-   * HTML:
-   * <div ng-channel="userChannel">Hello {{ user.firstName }} {{ user.lastName }}</div>
-   *
-   * JavaScript:
-   * angular.$eventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
-   *
-   * @param {import("../../core/pubsub/pubsub.js").PubSub} $eventBus
+   * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
    * @returns {import("../../interface.ts").Directive}
    */
   function ngChannelDirective($eventBus) {
     return {
       link: (scope, element, attrs) => {
-        const hasTemplate = element.childNodes.length > 0;
         const channel = attrs["ngChannel"];
+        const hasTemplateContent = element.childNodes.length > 0;
 
-        const key = $eventBus.subscribe(channel, (val) => {
-          if (!hasTemplate) {
-            element.innerHTML = val;
-          } else {
-            if (isObject(val)) {
-              scope.$merge(val);
+        const key = $eventBus.subscribe(channel, (value) => {
+          if (hasTemplateContent) {
+            if (isObject(value)) {
+              scope.$merge(value);
             }
+          } else {
+            element.innerHTML = value;
           }
         });
 
@@ -35606,7 +35611,7 @@
   ngSetterDirective.$inject = ["$parse", "$log"];
   /**
    * @param {import('../../core/parse/interface.ts').ParseService} $parse
-   * @param {import('../../services/log.js').LogService} $log
+   * @param {import('../../services/log/interface.ts').LogService} $log
    * @returns {import('../../interface.ts').Directive}
    */
   function ngSetterDirective($parse, $log) {
@@ -35681,6 +35686,10 @@
   const ngPostDirective = defineDirective("post");
   const ngPutDirective = defineDirective("put");
 
+  /**
+   * @typedef {"click" | "change" | "submit"} EventType
+   */
+
   /**
    * Selects DOM event to listen for based on the element type.
    *
@@ -35789,9 +35798,9 @@
    */
   function createHttpDirective(method, attrName) {
     /**
-     * @param {{ [key: string]: Function }} $http
+     * @param {import("interface.ts").HttpService} $http
      * @param {import("../../core/compile/compile.js").CompileFn} $compile
-     * @param {import("../../services/log.js").LogService} $log
+     * @param {import("../../services/log/interface.ts").LogService} $log
      * @returns {import('../../interface.ts').Directive}
      */
     return function ($http, $compile, $log) {
@@ -36080,18 +36089,15 @@
 
   class Angular {
     constructor() {
-      Cache.clear(); // a ensure new instance of angular gets a clean cache
-
-      /** @type {Map<number, import("./core/cache/cache.js").ExpandoStore>} */
       this.$cache = Cache;
 
-      /** @type {import('./core/pubsub/pubsub.js').PubSub} */
+      /** @type {import('./services/pubsub/pubsub.js').PubSub} */
       this.$eventBus = EventBus;
 
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.7.3"; //inserted via rollup plugin
+      this.version = "0.7.4"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];