@angular-wave/angular.ts 0.8.4 → 0.9.1

package/@types/core/scope/scope.d.ts

@@ -16,10 +16,6 @@ export function createScope(target?: any, context?: Scope): Scope;
  * @property {Object} locals
  */
 export const $postUpdateQueue: any[];
-/**
- * @type {Function[]}
- */
-export const $$applyAsyncQueue: Function[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -57,6 +53,7 @@ export 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>}
  */
 export class Scope {
   /**

package/@types/interface.d.ts

@@ -1,6 +1,3 @@
-import { Attributes } from "./core/compile/attributes.js";
-import { Scope } from "./core/scope/scope.js";
-export * from "./core/di/ng-module.js";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
@@ -9,6 +6,23 @@ export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
 export * from "./services/template-cache/interface.ts";
 export * from "./services/template-cache/template-cache.js";
+import { Attributes } from "./core/compile/attributes.js";
+import { Scope } from "./core/scope/scope.js";
+import { NgModule } from "./core/di/ng-module.js";
+import { PubSubProvider, PubSub } from "./services/pubsub/pubsub.js";
+import type { ErrorHandlingConfig as iErrorHandlingConfig } from "./shared/interface.ts";
+declare global {
+  interface Function {
+    $inject?: readonly string[] | undefined;
+  }
+  namespace ng {
+    type Scope = typeof Scope;
+    type NgModule = typeof NgModule;
+    type PubSubProvider = typeof PubSubProvider;
+    type PubSub = typeof PubSub;
+    type ErrorHandlingConfig = iErrorHandlingConfig;
+  }
+}
 /**
  * A JavaScript expression represented as a string, typically used in interpolation bindings.
  *

package/@types/shared/interface.d.ts

@@ -1,2 +1,19 @@
 export type Predicate<X> = (x?: X) => boolean;
 export type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
+/**
+ * Error configuration object. May only contain the options that need to be updated.
+ */
+export interface ErrorHandlingConfig {
+  /**
+   * The max depth for stringifying objects.
+   * Setting to a non-positive or non-numeric value removes the max depth limit.
+   * Default: 5.
+   */
+  objectMaxDepth?: number;
+  /**
+   * 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.
+   */
+  urlErrorParamsEnabled?: boolean;
+}

package/@types/shared/utils.d.ts

@@ -442,12 +442,12 @@ export function assertArgFn(
  *
  * 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}
  */
 export function errorHandlingConfig(
-  config?: ErrorHandlingConfig,
-): ErrorHandlingConfig;
+  config?: import("./interface.ts").ErrorHandlingConfig,
+): import("./interface.ts").ErrorHandlingConfig;
 /**
  * This object provides a utility for producing rich Error messages within
  * AngularTS. It can be called as follows:
@@ -573,18 +573,3 @@ export function wait(t?: number): Promise<void>;
 export function startsWith(str: string, search: string): boolean;
 export const isProxySymbol: unique symbol;
 export const ngAttrPrefixes: string[];
-/**
- * Error configuration object. May only contain the options that need to be updated.
- */
-export type ErrorHandlingConfig = {
-  /**
-   * - The max depth for stringifying objects. Setting to a
-   * non-positive or non-numeric value removes the max depth limit. Default: 5.
-   */
-  objectMaxDepth?: number | undefined;
-  /**
-   * - 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.
-   */
-  urlErrorParamsEnabled?: boolean | undefined;
-};

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.8.4 - September 5, 2025 23:28:30 */
+/* 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)
@@ -15453,7 +15445,11 @@ class ASTInterpreter {
           ? (scope, locals, assign) => {
               const values = [];
               for (let i = 0; i < args.length; ++i) {
-                const res = args[i](scope.$target, locals, assign);
+                const res = args[i](
+                  scope && scope.$target ? scope.$target : scope,
+                  locals,
+                  assign,
+                );
                 values.push(res);
               }
               const value = () => {
@@ -15541,7 +15537,7 @@ class ASTInterpreter {
           return context ? { value } : value;
         };
       case ASTType.ThisExpression:
-        return (scope) => (context ? { value: scope } : scope);
+        return (scope) => (context ? { value: scope } : scope.$proxy);
       case ASTType.LocalsExpression:
         // @ts-ignore
         return (scope, locals) => (context ? { value: locals } : locals);
@@ -15817,9 +15813,9 @@ class ASTInterpreter {
    */
   "ternary?:"(test, alternate, consequent, context) {
     return (scope, locals, assign) => {
-      const arg = test(scope.$target, locals, assign)
-        ? alternate(scope.$target, locals, assign)
-        : consequent(scope.$target, locals, assign);
+      const arg = test(scope, locals, assign)
+        ? alternate(scope, locals, assign)
+        : consequent(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -15844,7 +15840,8 @@ class ASTInterpreter {
    */
   identifier(name, context, create) {
     return (scope, locals) => {
-      const base = locals && name in locals ? locals : scope;
+      const base =
+        locals && name in locals ? locals : ((scope && scope.$proxy) ?? scope);
       if (create && create !== 1 && base && base[name] == null) {
         base[name] = {};
       }
@@ -20208,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 {
   /**
@@ -20623,6 +20621,7 @@ class Scope {
     return true;
   }
 
+  /** @internal **/
   #checkeListenersForAllKeys(value) {
     if (isUndefined(value)) {
       return;
@@ -20860,8 +20859,8 @@ class Scope {
               keySet.push(prop.value.name);
               listener.property.push(key);
             } else {
-              key =
-                get.decoratedNode.body[0].expression.toWatch[0].property.name;
+              const target = get.decoratedNode.body[0].expression.toWatch[0];
+              key = target.property ? target.property.name : target.name;
               listener.property.push(key);
             }
           }
@@ -20962,6 +20961,7 @@ class Scope {
     return proxy;
   }
 
+  /** @internal **/
   #registerKey(key, listener) {
     if (this.watchers.has(key)) {
       this.watchers.get(key).push(listener);
@@ -20970,6 +20970,7 @@ class Scope {
     }
   }
 
+  /** @internal **/
   #registerForeignKey(key, listener) {
     if (this.foreignListeners.has(key)) {
       this.foreignListeners.get(key).push(listener);
@@ -21101,7 +21102,8 @@ class Scope {
   }
 
   /**
-   * @returns {void}
+   * @internal
+   * @returns {any}
    */
   #eventHelper({ name, event, broadcast }, ...args) {
     if (!broadcast) {
@@ -21182,6 +21184,7 @@ class Scope {
   }
 
   /**
+   * @internal
    * @returns {boolean}
    */
   #isRoot() {
@@ -21216,6 +21219,7 @@ class Scope {
   }
 
   /**
+   * @internal
    * @param {Listener} listener - The property path that was changed.
    */
   #notifyListener(listener, target) {
@@ -23251,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
@@ -23972,7 +23976,7 @@ function AnimateQueueProvider($animateProvider) {
 AnimateJsProvider.$inject = ["$animateProvider"];
 function AnimateJsProvider($animateProvider) {
   this.$get = [
-    "$injector",
+    $injectTokens.$injector,
     "$$AnimateRunner",
     /**
      *
@@ -25830,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]]
@@ -27944,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));
   }
@@ -27982,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) => {
@@ -29698,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)
    *
@@ -31014,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$) {
@@ -31183,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;
@@ -34111,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
@@ -34155,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}
      */
@@ -35820,7 +35702,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.8.4"; //inserted via rollup plugin
+    this.version = "0.9.1"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];