Version bump 0.9.1

Author: tolyo

dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.0 - September 12, 2025 22:41:28 */
+/* Version: 0.9.1 - October 8, 2025 04:11:27 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -906,16 +906,7 @@ function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
-/**
- * @typedef {Object} ErrorHandlingConfig
- * Error configuration object. May only contain the options that need to be updated.
- * @property {number=} objectMaxDepth - The max depth for stringifying objects. Setting to a
- *   non-positive or non-numeric value removes the max depth limit. Default: 5.
- * @property {boolean=} urlErrorParamsEnabled - Specifies whether the generated error URL will
- *   contain the parameters of the thrown error. Default: true. When used without argument, it returns the current value.
- */
-
-/** @type {ErrorHandlingConfig} */
+/** @type {import("./interface.js").ErrorHandlingConfig} */
 const minErrConfig = {
   objectMaxDepth: 5,
   urlErrorParamsEnabled: true,
@@ -927,8 +918,8 @@ const minErrConfig = {
  *
  * Omitted or undefined options will leave the corresponding configuration values unchanged.
  *
- * @param {ErrorHandlingConfig} [config]
- * @returns {ErrorHandlingConfig}
+ * @param {import("./interface.ts").ErrorHandlingConfig} [config]
+ * @returns {import("./interface.ts").ErrorHandlingConfig}
  */
 function errorHandlingConfig(config) {
   if (isObject(config)) {
@@ -12386,6 +12377,7 @@ const optGroupTemplate = document.createElement("optgroup");
 
 const NG_OPTIONS_REGEXP =
   /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([$\w][$\w]*)|(?:\(\s*([$\w][$\w]*)\s*,\s*([$\w][$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/;
+
 // 1: value expression (valueFn)
 // 2: label expression (displayFn)
 // 3: group by expression (groupByFn)
@@ -20213,6 +20205,7 @@ const NONSCOPE = "$nonscope";
  * Scope class for the Proxy. It intercepts operations like property access (get)
  * and property setting (set), and adds support for deep change tracking and
  * observer-like behavior.
+ * @extends {Record<string, any>}
  */
 class Scope {
   /**
@@ -20628,6 +20621,7 @@ class Scope {
     return true;
   }
 
+  /** @internal **/
   #checkeListenersForAllKeys(value) {
     if (isUndefined(value)) {
       return;
@@ -20967,6 +20961,7 @@ class Scope {
     return proxy;
   }
 
+  /** @internal **/
   #registerKey(key, listener) {
     if (this.watchers.has(key)) {
       this.watchers.get(key).push(listener);
@@ -20975,6 +20970,7 @@ class Scope {
     }
   }
 
+  /** @internal **/
   #registerForeignKey(key, listener) {
     if (this.foreignListeners.has(key)) {
       this.foreignListeners.get(key).push(listener);
@@ -21106,7 +21102,8 @@ class Scope {
   }
 
   /**
-   * @returns {void}
+   * @internal
+   * @returns {any}
    */
   #eventHelper({ name, event, broadcast }, ...args) {
     if (!broadcast) {
@@ -21187,6 +21184,7 @@ class Scope {
   }
 
   /**
+   * @internal
    * @returns {boolean}
    */
   #isRoot() {
@@ -21221,6 +21219,7 @@ class Scope {
   }
 
   /**
+   * @internal
    * @param {Listener} listener - The property path that was changed.
    */
   #notifyListener(listener, target) {
@@ -23256,15 +23255,15 @@ function AnimateQueueProvider($animateProvider) {
   });
 
   this.$get = [
-    "$rootScope",
-    "$injector",
-    "$$animation",
-    "$$AnimateRunner",
-    "$templateRequest",
+    $injectTokens.$rootScope,
+    $injectTokens.$injector,
+    $injectTokens.$$animation,
+    $injectTokens.$$AnimateRunner,
+    $injectTokens.$templateRequest,
     /**
      *
      * @param {import('../core/scope/scope.js').Scope} $rootScope
-     * @param {*} $injector
+     * @param {import('../core/di/internal-injector.js').InjectorService} $injector
      * @param {*} $$animation
      * @param {*} $$AnimateRunner
      * @param {*} $templateRequest
@@ -23977,7 +23976,7 @@ function AnimateQueueProvider($animateProvider) {
 AnimateJsProvider.$inject = ["$animateProvider"];
 function AnimateJsProvider($animateProvider) {
   this.$get = [
-    "$injector",
+    $injectTokens.$injector,
     "$$AnimateRunner",
     /**
      *
@@ -25835,20 +25834,6 @@ const anyTrueR = (memo, elem) => memo || elem;
  * ```
  */
 const unnestR = (memo, elem) => memo.concat(elem);
-/**
- * Reduce function which recursively un-nests all arrays
- *
- * @example
- * ```
- *
- * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
- * input.reduce(unnestR, []) // [ "a", "b", "c", "d", "double, "nested" ]
- * ```
- */
-const flattenR = (memo, elem) =>
-  Array.isArray(elem)
-    ? memo.concat(elem.reduce(flattenR, []))
-    : pushR(memo, elem);
 /**
  * Reduce function that pushes an object to an array, then returns the array.
  * Mostly just for [[flattenR]] and [[uniqR]]
@@ -27949,10 +27934,6 @@ class ResolveContext {
     return Promise.all(promises);
   }
 
-  injector() {
-    return this._injector || (this._injector = new UIInjectorImpl());
-  }
-
   findNode(resolvable) {
     return find(this._path, (node) => node.resolvables.includes(resolvable));
   }
@@ -27987,21 +27968,6 @@ class ResolveContext {
   }
 }
 
-class UIInjectorImpl {
-  constructor() {
-    this.native = window["angular"].$injector;
-  }
-  get(token) {
-    return window["angular"].$injector.get(token);
-  }
-  getAsync(token) {
-    return Promise.resolve(window["angular"].$injector.get(token));
-  }
-  getNative(token) {
-    return window["angular"].$injector.get(token);
-  }
-}
-
 function getViewConfigFactory() {
   let templateFactory = null;
   return (path, view) => {
@@ -29703,90 +29669,7 @@ class Transition {
         .reduce((acc, obj) => ({ ...acc, ...obj }), {}),
     );
   }
-  paramsChanged() {
-    const fromParams = this.params("from");
-    const toParams = this.params("to");
-    // All the parameters declared on both the "to" and "from" paths
-    const allParamDescriptors = []
-      .concat(this._treeChanges.to)
-      .concat(this._treeChanges.from)
-      .map((pathNode) => pathNode.paramSchema)
-      .reduce(flattenR, [])
-      .reduce(uniqR, []);
-    const changedParamDescriptors = Param.changed(
-      allParamDescriptors,
-      fromParams,
-      toParams,
-    );
-    return changedParamDescriptors.reduce((changedValues, descriptor) => {
-      changedValues[descriptor.id] = toParams[descriptor.id];
-      return changedValues;
-    }, {});
-  }
-  /**
-   * Creates a [[UIInjector]] Dependency Injector
-   *
-   * Returns a Dependency Injector for the Transition's target state (to state).
-   * The injector provides resolve values which the target state has access to.
-   *
-   * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).
-   *
-   * #### Example:
-   * ```js
-   * .onEnter({ entering: 'myState' }, trans => {
-   *   var myResolveValue = trans.injector().get('myResolve');
-   *   // Inject a global service from the global/native injector (if it exists)
-   *   var MyService = trans.injector().get('MyService');
-   * })
-   * ```
-   *
-   * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.
-   * You can use [[UIInjector.getAsync]] to get a promise for the data.
-   * #### Example:
-   * ```js
-   * .onBefore({}, trans => {
-   *   return trans.injector().getAsync('myResolve').then(myResolveValue =>
-   *     return myResolveValue !== 'ABORT';
-   *   });
-   * });
-   * ```
-   *
-   * If a `state` is provided, the injector that is returned will be limited to resolve values that the provided state has access to.
-   * This can be useful if both a parent state `foo` and a child state `foo.bar` have both defined a resolve such as `data`.
-   * #### Example:
-   * ```js
-   * .onEnter({ to: 'foo.bar' }, trans => {
-   *   // returns result of `foo` state's `myResolve` resolve
-   *   // even though `foo.bar` also has a `myResolve` resolve
-   *   var fooData = trans.injector('foo').get('myResolve');
-   * });
-   * ```
-   *
-   * If you need resolve data from the exiting states, pass `'from'` as `pathName`.
-   * The resolve data from the `from` path will be returned.
-   * #### Example:
-   * ```js
-   * .onExit({ exiting: 'foo.bar' }, trans => {
-   *   // Gets the resolve value of `myResolve` from the state being exited
-   *   var fooData = trans.injector(null, 'from').get('myResolve');
-   * });
-   * ```
-   *
-   *
-   * @param state Limits the resolves provided to only the resolves the provided state has access to.
-   * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.
-   *
-   * @returns a [[UIInjector]]
-   */
-  injector(state, pathName = "to") {
-    let path = this._treeChanges[pathName];
-    if (state)
-      path = PathUtils.subPath(
-        path,
-        (node) => node.state === state || node.state.name === state,
-      );
-    return new ResolveContext(path).injector();
-  }
+
   /**
    * Gets all available resolve tokens (keys)
    *
@@ -31019,19 +30902,20 @@ class StateProvider {
     return this.globals.$current;
   }
 
-  /* @ignore */ static $inject = ["$routerProvider", "$transitionsProvider"];
+  static $inject = ["$routerProvider", "$transitionsProvider"];
 
-  // Needs access to urlService, stateRegistry
   /**
    *
    * @param {import('../router.js').Router} globals
    * @param {*} transitionService
+   * @param {import('../../core/di/internal-injector.js').InjectorService} $injector
    */
-  constructor(globals, transitionService) {
+  constructor(globals, transitionService, $injector) {
     this.stateRegistry = undefined;
     this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
+    this.$injector = $injector;
     this.invalidCallbacks = [];
 
     this._defaultErrorHandler = function $defaultErrorHandler($error$) {
@@ -31188,7 +31072,7 @@ class StateProvider {
     const latest = latestThing();
     /** @type {Queue<Function>} */
     const callbackQueue = new Queue(this.invalidCallbacks.slice());
-    const injector = new ResolveContext(fromPath).injector();
+    const injector = this.$injector;
     const checkForRedirect = (result) => {
       if (!(result instanceof TargetState)) {
         return;
@@ -34116,12 +34000,7 @@ class StateQueueManager {
  *
  */
 class StateRegistryProvider {
-  /* @ignore */ static $inject = provider([
-    $injectTokens.$url,
-    $injectTokens.$state,
-    $injectTokens.$router,
-    $injectTokens.$view,
-  ]);
+  static $inject = provider([$injectTokens.$url, $injectTokens.$state, $injectTokens.$router, $injectTokens.$view]);
 
   /**
    * @param urlService
@@ -34160,11 +34039,9 @@ class StateRegistryProvider {
     globals.current = globals.$current.self;
   }
 
-  /** @type {import('../../interface.ts').AnnotatedFactory} */
   $get = [
-    "$injector",
+    $injectTokens.$injector,
     /**
-     *
      * @param {import("../../core/di/internal-injector").InjectorService} $injector
      * @returns {StateRegistryProvider}
      */
@@ -35825,7 +35702,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.9.0"; //inserted via rollup plugin
+    this.version = "0.9.1"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];