@angular-wave/angular.ts 0.8.0 → 0.8.1

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.8.0 - August 2, 2025 17:22:29 */
+/* Version: 0.8.1 - August 7, 2025 18:30:07 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1816,11 +1816,11 @@
     $interpolate: "$interpolate",
     $location: "$location",
     $log: "$log",
-    $ngViewScroll: "$ngViewScroll",
+    $viewScroll: "$viewScroll",
     $parse: "$parse",
     $rootScope: "$rootScope",
     $rootElement: "$rootElement",
-    $routerGlobals: "$routerGlobals",
+    $router: "$router",
     $sce: "$sce",
     $sceDelegate: "$sceDelegate",
     $state: "$state",
@@ -1874,7 +1874,7 @@
     /**
      * @param {string} name - Name of the module
      * @param {Array<string>} requires - List of modules which the injector will load before the current module
-     * @param {Function} [configFn]
+     * @param {import("../../interface.js").Injectable} [configFn]
      */
     constructor(name, requires, configFn) {
       assert(isString(name), "name required");
@@ -1900,7 +1900,7 @@
       /** @type {!Array<Array<*>>} */
       this.configBlocks = [];
 
-      /** @type {!Array.<Function>} */
+      /** @type {!Array.<import("../../interface.js").Injectable>} */
       this.runBlocks = [];
 
       if (configFn) {
@@ -1930,7 +1930,7 @@
 
     /**
      *
-     * @param {Function} configFn
+     * @param {import("../../interface.js").Injectable} configFn
      * @returns {NgModule}
      */
     config(configFn) {
@@ -1939,7 +1939,7 @@
     }
 
     /**
-     * @param {Function} block
+     * @param {import("../../interface.js").Injectable} block
      * @returns {NgModule}
      */
     run(block) {
@@ -1949,12 +1949,12 @@
 
     /**
      * @param {string} name
-     * @param {*} options
+     * @param {import("../../interface.js").Injectable} options
      * @returns {NgModule}
      */
     component(name, options) {
       if (options && isFunction(options)) {
-        options.$$moduleName = name;
+        options["$$moduleName"] = name;
       }
       this.invokeQueue.push([COMPILE_LITERAL, "component", [name, options]]);
       return this;
@@ -1962,12 +1962,12 @@
 
     /**
      * @param {string} name
-     * @param {*} providerFunction
+     * @param {import("../../interface.js").Injectable} providerFunction
      * @returns {NgModule}
      */
     factory(name, providerFunction) {
       if (providerFunction && isFunction(providerFunction)) {
-        providerFunction.$$moduleName = name;
+        providerFunction["$$moduleName"] = name;
       }
       this.invokeQueue.push([$injectTokens.$provide, "factory", [name, providerFunction]]);
       return this;
@@ -1975,12 +1975,12 @@
 
     /**
      * @param {string} name
-     * @param {*} serviceFunction
+     * @param {import("../../interface.js").Injectable} serviceFunction
      * @returns {NgModule}
      */
     service(name, serviceFunction) {
       if (serviceFunction && isFunction(serviceFunction)) {
-        serviceFunction.$$moduleName = name;
+        serviceFunction["$$moduleName"] = name;
       }
       this.invokeQueue.push([$injectTokens.$provide, "service", [name, serviceFunction]]);
       return this;
@@ -1988,12 +1988,12 @@
 
     /**
      * @param {string} name
-     * @param {*} providerType
+     * @param {import("../../interface.js").Injectable} providerType
      * @returns {NgModule}
      */
     provider(name, providerType) {
       if (providerType && isFunction(providerType)) {
-        providerType.$$moduleName = name;
+        providerType["$$moduleName"] = name;
       }
       this.invokeQueue.push([$injectTokens.$provide, "provider", [name, providerType]]);
       return this;
@@ -2001,12 +2001,12 @@
 
     /**
      * @param {string} name
-     * @param {*} decorFn
+     * @param {import("../../interface.js").Injectable} decorFn
      * @returns {NgModule}
      */
     decorator(name, decorFn) {
       if (decorFn && isFunction(decorFn)) {
-        decorFn.$$moduleName = name;
+        decorFn["$$moduleName"] = name;
       }
       this.configBlocks.push([$injectTokens.$provide, "decorator", [name, decorFn]]);
       return this;
@@ -2014,12 +2014,12 @@
 
     /**
      * @param {string} name
-     * @param {*} directiveFactory
+     * @param {import("../../interface.js").Injectable} directiveFactory
      * @returns {NgModule}
      */
     directive(name, directiveFactory) {
       if (directiveFactory && isFunction(directiveFactory)) {
-        directiveFactory.$$moduleName = name;
+        directiveFactory["$$moduleName"] = name;
       }
       this.invokeQueue.push([
         COMPILE_LITERAL,
@@ -2031,12 +2031,12 @@
 
     /**
      * @param {string} name
-     * @param {*} animationFactory
+     * @param {import("../../interface.js").Injectable} animationFactory
      * @returns {NgModule}
      */
     animation(name, animationFactory) {
       if (animationFactory && isFunction(animationFactory)) {
-        animationFactory.$$moduleName = name;
+        animationFactory["$$moduleName"] = name;
       }
       this.invokeQueue.push([
         ANIMATION_LITERAL,
@@ -2046,9 +2046,14 @@
       return this;
     }
 
+    /**
+     * @param {string} name
+     * @param {import("../../interface.js").Injectable} filterFn
+     * @return {NgModule}
+     */
     filter(name, filterFn) {
       if (filterFn && isFunction(filterFn)) {
-        filterFn.$$moduleName = name;
+        filterFn["$$moduleName"] = name;
       }
       this.invokeQueue.push([FILTER_LITERAL, "register", [name, filterFn]]);
       return this;
@@ -2056,12 +2061,12 @@
 
     /**
      * @param {string} name
-     * @param {*} ctlFn
+     * @param {import("../../interface.js").Injectable} ctlFn
      * @returns {NgModule}
      */
     controller(name, ctlFn) {
       if (ctlFn && isFunction(ctlFn)) {
-        ctlFn.$$moduleName = name;
+        ctlFn["$$moduleName"] = name;
       }
       this.invokeQueue.push([CONTROLLER_LITERAL, "register", [name, ctlFn]]);
       return this;
@@ -11972,7 +11977,7 @@
       transclude: "element",
       priority: 1000,
       terminal: true,
-      compile: ($element, $attr) => {
+      compile: (_$element, $attr) => {
         const expression = $attr["ngRepeat"];
         const hasAnimate = !!$attr["animate"];
 
@@ -19088,8 +19093,15 @@
      */
     setUrl(url) {
       const match = PATH_MATCH.exec(url);
-      if (match[1] || url === "") this.setPath(decodeURIComponent(match[1]));
-      if (match[2] || match[1] || url === "") this.setSearch(match[3] || "");
+
+      if (match[1] !== undefined || url === "") {
+        this.setPath(match[1] || "");
+      }
+
+      if (match[2] !== undefined || match[1] !== undefined || url === "") {
+        this.setSearch(match[3] || "");
+      }
+
       this.setHash(match[5] || "");
 
       return this;
@@ -25501,20 +25513,6 @@
       name.split(".").map((name) => (obj) => obj && obj[name]),
     );
 
-  /**
-   * Given two functions that return truthy or falsey values, returns a function that returns truthy
-   * if at least one of the functions returns truthy for the given arguments
-   */
-  function or(fn1, fn2) {
-    return (...args) => fn1.apply(null, args) || fn2.apply(null, args);
-  }
-  /**
-   * Check if all the elements of an array match a predicate function
-   *
-   * @param fn1 a predicate function `fn1`
-   * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
-   */
-  const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
   /** Given a class, returns a Predicate function that returns true if the object is of that class */
   const is = (ctor) => (obj) =>
     (obj != null && obj.constructor === ctor) || obj instanceof ctor;
@@ -25577,10 +25575,10 @@
       t2 = typeof o2;
     if (t1 !== t2 || t1 !== "object") return false;
     const tup = [o1, o2];
-    if (all(Array.isArray)(tup)) return _arraysEq(o1, o2);
-    if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
-    if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
-    if (all(isFunction)(tup)) return true; // meh
+    if (tup.every(Array.isArray)) return _arraysEq(o1, o2);
+    if (tup.every(isDate)) return o1.getTime() === o2.getTime();
+    if (tup.every(isRegExp)) return o1.toString() === o2.toString();
+    if (tup.every(isFunction)) return true; // meh
     if ([isFunction, Array.isArray, isDate, isRegExp].some((fn) => !!fn(tup))) {
       return false;
     }
@@ -26022,7 +26020,6 @@
     /**
      * @param def  A configuration object which contains the custom type definition.  The object's
      *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
-     * @returns a new ParamType object
      */
     constructor(def) {
       this.pattern = /.*/;
@@ -26581,7 +26578,7 @@
    * This is where we hold the global mutable state such as current state, current
    * params, current transition, etc.
    */
-  class RouterGlobals {
+  class Router {
     constructor() {
       /**
        * Current parameter values
@@ -27475,7 +27472,7 @@
       const normalized = this.type.$normalize(value);
       if (!this.type.is(normalized)) return false;
       // The value was of the correct type, but when encoded, did not match the ParamType's regexp
-      const encoded = this.type.encode(normalized);
+      const encoded = normalized; // this.type.encode(normalized);
       return !(isString(encoded) && !this.type.pattern.exec(encoded));
     }
     toString() {
@@ -29562,11 +29559,11 @@
      *        encapsulates the "from state".
      * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
      * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
-     * @param {import('../globals.js').RouterGlobals} globals
+     * @param {import('../router.js').Router} globals
      */
     constructor(fromPath, targetState, transitionService, globals) {
       /**
-       * @type {import('../globals.js').RouterGlobals}
+       * @type {import('../router.js').Router}
        */
       this.globals = globals;
       this.transitionService = transitionService;
@@ -30746,10 +30743,10 @@
    * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
    */
   class TransitionProvider {
-    /* @ignore */ static $inject = provider([$injectTokens.$routerGlobals, $injectTokens.$view]);
+    /* @ignore */ static $inject = provider([$injectTokens.$router, $injectTokens.$view]);
 
     /**
-     * @param {import('../globals.js').RouterGlobals} globals
+     * @param {import('../router.js').Router} globals
      * @param viewService
      */
     constructor(globals, viewService) {
@@ -30996,7 +30993,7 @@
     /**
      * The latest successful state parameters
      *
-     * @deprecated This is a passthrough through to [[RouterGlobals.params]]
+     * @deprecated This is a passthrough through to [[Router.params]]
      */
     get params() {
       return this.globals.params;
@@ -31004,7 +31001,7 @@
     /**
      * The current [[StateDeclaration]]
      *
-     * @deprecated This is a passthrough through to [[RouterGlobals.current]]
+     * @deprecated This is a passthrough through to [[Router.current]]
      */
     get current() {
       return this.globals.current;
@@ -31012,21 +31009,18 @@
     /**
      * The current [[StateObject]] (an internal API)
      *
-     * @deprecated This is a passthrough through to [[RouterGlobals.$current]]
+     * @deprecated This is a passthrough through to [[Router.$current]]
      */
     get $current() {
       return this.globals.$current;
     }
 
-    /* @ignore */ static $inject = [
-      "$routerGlobalsProvider",
-      "$transitionsProvider",
-    ];
+    /* @ignore */ static $inject = ["$routerProvider", "$transitionsProvider"];
 
     // Needs access to urlService, stateRegistry
     /**
      *
-     * @param {import('../globals.js').RouterGlobals} globals
+     * @param {import('../router.js').Router} globals
      * @param {*} transitionService
      */
     constructor(globals, transitionService) {
@@ -31677,7 +31671,7 @@
     }
 
     $get = [
-      "$anchorScroll",
+      $injectTokens.$anchorScroll,
       /**
        * @param {import('../services/anchor-scroll.js').AnchorScrollObject} $anchorScroll
        * @returns {import('../services/anchor-scroll.js').AnchorScrollObject|Function}
@@ -32020,13 +32014,6 @@
    *
    */
   class UrlMatcher {
-    static encodeDashes(str) {
-      // Replace dashes with encoded "\-"
-      return encodeURIComponent(str).replace(
-        /-/g,
-        (c) => `%5C%${c.charCodeAt(0).toString(16).toUpperCase()}`,
-      );
-    }
     /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
     static pathSegmentsAndParams(matcher) {
       const staticSegments = matcher._segments;
@@ -32237,9 +32224,6 @@
       return this.pattern;
     }
     _getDecodedParamValue(value, param) {
-      if (isDefined(value)) {
-        value = param.type.decode(value);
-      }
       return param.value(value);
     }
     /**
@@ -32430,7 +32414,7 @@
         if (encoded == null) return acc;
         // If this parameter value is an array, encode the value using encodeDashes
         if (Array.isArray(encoded))
-          return acc + map(encoded, UrlMatcher.encodeDashes).join("-");
+          return acc + map(encoded, encodeDashes).join("-");
         // If the parameter type is "raw", then do not encodeURIComponent
         if (param.raw) return acc + encoded;
         // Encode the value
@@ -32460,6 +32444,14 @@
 
   UrlMatcher.nameValidator = /^\w+([-.]+\w+)*(?:\[\])?$/;
 
+  function encodeDashes(str) {
+    // Replace dashes with encoded "\-"
+    return encodeURIComponent(str).replace(
+      /-/g,
+      (c) => `%5C%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+    );
+  }
+
   /** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
 
   /**
@@ -32585,6 +32577,11 @@
    * - [[StateObject]]
    */
   class UrlRuleFactory {
+    /**
+     * @param {import('../url/url-service.js').UrlService} urlService
+     * @param {import('../state/state-service.js').StateProvider} stateService
+     * @param {import('../router.js').Router} routerGlobals
+     */
     constructor(urlService, stateService, routerGlobals) {
       this.urlService = urlService;
       this.stateService = stateService;
@@ -32603,7 +32600,7 @@
         [isString, (_what) => makeRule(this.urlService.compile(_what))],
         [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
         [
-          or(isState, isStateDeclaration),
+          (...args) => isState(...args) || isStateDeclaration(...args),
           (_what) => this.fromState(_what, this.stateService, this.routerGlobals),
         ],
         [is(RegExp), (_what) => this.fromRegExp(_what, handler)],
@@ -33164,7 +33161,7 @@
     static $inject = provider([
       $injectTokens.$location,
       $injectTokens.$state,
-      $injectTokens.$routerGlobals,
+      $injectTokens.$router,
       $injectTokens.$urlConfig,
     ]);
 
@@ -33174,7 +33171,7 @@
     /**
      * @param {import("../../services/location/location").LocationProvider} $locationProvider
      * @param {import("../../router/state/state-service.js").StateProvider} stateService
-     * @param {import("../../router/globals.js").RouterGlobals} globals
+     * @param {import("../router.js").Router} globals
      * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
      */
     constructor($locationProvider, stateService, globals, urlConfigProvider) {
@@ -33317,7 +33314,10 @@
      * @return the url (after potentially being processed)
      */
     url(newUrl, state) {
-      if (isDefined(newUrl)) this.$location.setUrl(newUrl);
+      if (isDefined(newUrl)) {
+        const decodeUri = decodeURIComponent(newUrl);
+        this.$location.setUrl(decodeUri);
+      }
       if (state) this.$location.setState(state);
       return this.$location.getUrl();
     }
@@ -34115,14 +34115,14 @@
     /* @ignore */ static $inject = provider([
       $injectTokens.$url,
       $injectTokens.$state,
-      $injectTokens.$routerGlobals,
+      $injectTokens.$router,
       $injectTokens.$view,
     ]);
 
     /**
      * @param urlService
      * @param stateService
-     * @param {import('../globals.js').RouterGlobals} globals
+     * @param {import('../router.js').Router} globals
      * @param viewService
      */
     constructor(urlService, stateService, globals, viewService) {
@@ -34601,7 +34601,7 @@
 
   $StateRefActiveDirective.$inject = [
     "$state",
-    "$routerGlobals",
+    "$router",
     "$interpolate",
     "$stateRegistry",
     "$transitions",
@@ -34609,7 +34609,7 @@
 
   /**
    * @param {*} $state
-   * @param {import('../globals.js').RouterGlobals} $routerGlobals
+   * @param {import('../router.js').Router} $router
    * @param {*} $interpolate
    * @param {*} $stateRegistry
    * @param {*} $transitions
@@ -34617,7 +34617,7 @@
    */
   function $StateRefActiveDirective(
     $state,
-    $routerGlobals,
+    $router,
     $interpolate,
     $stateRegistry,
     $transitions,
@@ -34656,8 +34656,8 @@
           trans.promise.then(update, () => {});
         }
         $scope.$on("$destroy", setupEventListeners());
-        if ($routerGlobals.transition) {
-          updateAfterTransition($routerGlobals.transition);
+        if ($router.transition) {
+          updateAfterTransition($router.transition);
         }
         function setupEventListeners() {
           const deregisterStatesChangedListener =
@@ -34759,7 +34759,7 @@
    *   The ng-view can be targeted in a View using the name ([[StateDeclaration.views]]).
    *
    * - `autoscroll`: an expression. When it evaluates to true, the `ng-view` will be scrolled into view when it is activated.
-   *   Uses [[$ngViewScroll]] to do the scrolling.
+   *   Uses [[$viewScroll]] to do the scrolling.
    *
    * - `onload`: Expression to evaluate whenever the view updates.
    *
@@ -34878,16 +34878,16 @@
   let ngView = [
     "$view",
     "$animate",
-    "$ngViewScroll",
+    "$viewScroll",
     "$interpolate",
     /**
      * @param {*} $view
      * @param {*} $animate
-     * @param {*} $ngViewScroll
+     * @param {*} $viewScroll
      * @param {*} $interpolate
      * @returns {import("../../interface.js").Directive}
      */
-    function $ViewDirective($view, $animate, $ngViewScroll, $interpolate) {
+    function $ViewDirective($view, $animate, $viewScroll, $interpolate) {
       function getRenderer() {
         return {
           enter: function (element, target, cb) {
@@ -35024,7 +35024,7 @@
                     (isDefined(autoScrollExp) && !autoScrollExp) ||
                     scope.$eval(autoScrollExp)
                   ) {
-                    $ngViewScroll(clone);
+                    $viewScroll(clone);
                   }
                 });
                 cleanupLastView();
@@ -35769,7 +35769,7 @@
               $parse: ParseProvider,
               $$rAFScheduler: RafSchedulerProvider,
               $rootScope: RootScopeProvider,
-              $routerGlobals: RouterGlobals,
+              $router: Router,
               $sce: SceProvider,
               $sceDelegate: SceDelegateProvider,
               $templateCache: TemplateCacheProvider,
@@ -35778,7 +35778,7 @@
               $view: ViewService,
               $transitions: TransitionProvider,
               $state: StateProvider,
-              $ngViewScroll: ViewScrollProvider,
+              $viewScroll: ViewScrollProvider,
               $templateFactory: TemplateFactoryProvider,
               $url: UrlService,
               $stateRegistry: StateRegistryProvider,
@@ -35788,9 +35788,9 @@
         ],
       )
       .factory("$stateParams", [
-        $injectTokens.$routerGlobals,
+        $injectTokens.$router,
         /**
-         * @param {import('./router/globals.js').RouterGlobals} globals
+         * @param {import('./router/router.js').Router} globals
          * @returns {import('./router/params/state-params.js').StateParams }
          */
         (globals) => globals.params,
@@ -35821,7 +35821,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.8.0"; //inserted via rollup plugin
+      this.version = "0.8.1"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];
@@ -35830,9 +35830,9 @@
       this.getInjector = getInjector;
       this.getScope = getScope;
       this.errorHandlingConfig = errorHandlingConfig;
+      this.$t = $injectTokens;
 
       window["angular"] = this;
-      this.$injectTokens = $injectTokens;
       registerNgModule(this);
     }
 
@@ -35909,14 +35909,14 @@
 
       const injector = createInjector(this.bootsrappedModules, config.strictDi);
       injector.invoke([
-        "$rootScope",
-        "$rootElement",
-        "$compile",
-        "$injector",
+        $injectTokens.$rootScope,
+        $injectTokens.$rootElement,
+        $injectTokens.$compile,
+        $injectTokens.$injector,
         /**
          * @param {import('./core/scope/scope.js').Scope} scope
          * @param {Element} el
-         * @param {*} compile
+         * @param {import("./core/compile/compile.js").CompileFn} compile
          * @param {import("./core/di/internal-injector.js").InjectorService} $injector
          */
         (scope, el, compile, $injector) => {
@@ -35939,7 +35939,7 @@
           }
 
           $injector
-            .get("$stateRegistry")
+            .get($injectTokens.$stateRegistry)
             .get()
             .map((x) => x.$$state().resolvables)
             .reduce(unnestR, [])
@@ -36044,7 +36044,7 @@
      * @param {string} name The name of the module to create or retrieve.
      * @param {Array.<string>} [requires] If specified then new module is being created. If
      *        unspecified then the module is being retrieved for further configuration.
-     * @param {Array<any>|Function} [configFn] Optional configuration function for the module that gets
+     * @param {import("./interface.js").Injectable} [configFn] Optional configuration function for the module that gets
      *        passed to {@link NgModule.config NgModule.config()}.
      * @returns {NgModule} A newly registered module.
      */
@@ -36061,7 +36061,7 @@
             name,
           );
         }
-        return new NgModule(name, requires, /** @type {Function} */ (configFn));
+        return new NgModule(name, requires, configFn);
       });
     }
   }