@tstdl/base 0.87.8 → 0.87.10

package/authentication/client/module.js

@@ -38,7 +38,7 @@ function configureAuthenticationClient(config, injector = (0, import_inject.getC
   if ((0, import_type_guards.isDefined)(config.registerMiddleware)) {
     (injector ?? import_injector.Injector).register(import_tokens.HTTP_CLIENT_MIDDLEWARE, {
       useFactory(_, context) {
-        const authenticationService = context.resolve(import_authentication_service.AuthenticationService);
+        const authenticationService = context.resolve(import_authentication_service.AuthenticationService, void 0, { forwardRef: true, forwardRefTypeHint: "object" });
         return (0, import_http_client_middleware.waitForAuthenticationCredentialsMiddleware)(authenticationService);
       }
     }, { multi: true });

package/injector/decorators.d.ts

@@ -2,6 +2,7 @@ import type { Decorator } from '../reflection/index.js';
 import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../types.js';
 import type { Provider } from './provider.js';
 import type { InjectionToken } from './token.js';
+import type { InjectMetadata } from './type-info.js';
 import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
 export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
 export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
@@ -78,4 +79,4 @@ export declare function Optional(): InjectDecorator;
  * @param token token to resolve
  * @param argument resolve argument
  */
-export declare function ForwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;
+export declare function ForwardRef<T extends object, A>(token?: ForwardRefInjectionToken<T>, argument?: A, options?: Pick<InjectMetadata, 'forwardRefTypeHint'>): InjectDecorator;

package/injector/decorators.js

@@ -106,9 +106,10 @@ function ForwardArg(mapper = (value) => value) {
 function Optional() {
   return createInjectDecorator({ optional: true });
 }
-function ForwardRef(token, argument) {
+function ForwardRef(token, argument, options) {
   const injectMetadata = {
-    forwardRefToken: token
+    forwardRef: token ?? true,
+    forwardRefTypeHint: options?.forwardRefTypeHint
   };
   if ((0, import_type_guards.isDefined)(argument)) {
     injectMetadata.resolveArgumentProvider = () => argument;

package/injector/inject.d.ts

@@ -2,22 +2,19 @@ import { Injector } from './injector.js';
 import type { Resolvable, ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { ResolveOptions } from './types.js';
-export type InjectOptions = ResolveOptions & {
-    /** if defined, resolve the ForwardRefToken using ForwardRef strategy instead resolving the token */
-    forwardRef?: boolean;
-};
+export type InjectOptions<T, A> = ResolveOptions<T, A>;
 export type InjectArgumentOptions = {
     optional?: boolean;
 };
 export type InjectionContext = {
     injector: Injector;
     argument: unknown;
-    inject<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
-    injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
-    injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
-    injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
+    inject<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T;
+    injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T[];
+    injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T>;
+    injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T[]>;
 };
-export type InjectManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions];
+export type InjectManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
 export type InjectManyItem<T, A> = InjectionToken<T, A> | InjectManyArrayItem<T, A>;
 export type InjectManyItemReturnType<T extends InjectManyItem<any, any>> = T extends InjectManyItem<infer U, any> ? U | (T extends (InjectManyArrayItem<any, any> & [any, any, {
     optional: true;
@@ -32,10 +29,10 @@ export type InjectManyReturnType<T extends InjectManyItem<any, any>[]> = {
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
     optional: true;
 }): T | undefined;
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions & {
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
     optional?: false;
 }): T;
 /**
@@ -51,10 +48,10 @@ export declare function injectMany<T extends InjectManyItem<any, any>[]>(...toke
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
     optional: true;
 }): Promise<T | undefined>;
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T>;
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
  *
@@ -68,7 +65,7 @@ export declare function injectManyAsync<T extends InjectManyItem<any, any>[]>(..
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
+export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T[];
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *
@@ -76,7 +73,7 @@ export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?:
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
+export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T[]>;
 /**
  * Injects the resolve argument from the current resolution
  * @param _this can be used for type infer by simply passing `this`. Requires class to implement {@link Resolvable}.

package/injector/injector.d.ts

@@ -68,16 +68,16 @@ export declare class Injector implements AsyncDisposable {
      * @param token token to get registration for
      */
     getRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[];
-    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
+    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
         optional: true;
     }): T | undefined;
-    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): T;
-    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): T[];
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
+    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T;
+    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T[];
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
         optional: true;
     }): Promise<T | undefined>;
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T>;
-    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T[]>;
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
+    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
     private _resolve;
     private _resolveAll;
     private _resolveRegistration;

package/injector/injector.js

@@ -202,6 +202,14 @@ class Injector {
   }
   _resolve(token, argument, options, context, chain) {
     this.assertNotDisposed();
+    if ((0, import_type_guards.isDefined)(options.forwardRef) && options.forwardRef != false) {
+      (0, import_type_guards.assert)(options.optional != true, "ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.");
+      const forwardRef = import_forward_ref.ForwardRef.create();
+      const forwardToken = (0, import_type_guards.isFunction)(options.forwardRef) ? options.forwardRef() : token;
+      context.forwardRefQueue.add(() => import_forward_ref.ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+      context.forwardRefs.add(forwardRef);
+      return forwardRef;
+    }
     if ((0, import_type_guards.isUndefined)(token)) {
       throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
     }
@@ -220,6 +228,13 @@ class Injector {
   }
   _resolveAll(token, argument, options, context, chain) {
     this.assertNotDisposed();
+    if ((0, import_type_guards.isDefined)(options.forwardRef) && options.forwardRef != false) {
+      const forwardRef = import_forward_ref.ForwardRef.create({ typeHint: options.forwardRefTypeHint });
+      const forwardToken = (0, import_type_guards.isFunction)(options.forwardRef) ? options.forwardRef() : token;
+      context.forwardRefQueue.add(() => import_forward_ref.ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+      context.forwardRefs.add(forwardRef);
+      return forwardRef;
+    }
     if ((0, import_type_guards.isUndefined)(token)) {
       throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
     }
@@ -307,9 +322,9 @@ class Injector {
         result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
       }
       if ((0, import_provider.isFactoryProvider)(provider)) {
+        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+        injectionContext.argument = arg;
         try {
-          const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-          injectionContext.argument = arg;
           result = { value: provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain)) };
         } catch (error) {
           throw new import_resolve_error.ResolveError("Error in provider factory.", chain, error);
@@ -327,61 +342,39 @@ class Injector {
     }
   }
   resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
-    const getChain = (injectToken2) => chain.addParameter(constructor, metadata.index, injectToken2).addToken(injectToken2);
+    const getChain = (injectToken2) => chain.addParameter(constructor, metadata.index, injectToken2);
     const injectMetadata = metadata.data.tryGet(import_symbols.injectMetadataSymbol) ?? {};
     const injectToken = injectMetadata.injectToken ?? metadata.type;
     if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
       return injectMetadata.injectArgumentMapper(resolveArgument);
     }
     const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
-    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardRefToken = injectMetadata.forwardRefToken;
+    const forwardRef = injectMetadata.forwardRef;
+    if ((0, import_type_guards.isDefined)(forwardRef)) {
       context.forwardRefQueue.add(() => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
+        const forwardToken = (0, import_type_guards.isFunction)(forwardRef) ? forwardRef() : (0, import_type_guards.isBoolean)(forwardRef) ? injectToken : forwardRef;
         if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
           throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
         }
-        const resolved2 = this[injectMetadata.resolveAll == true ? "_resolveAll" : "_resolve"](forwardToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(forwardToken));
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
       });
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
     }
-    const resolved = this._resolve(injectToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(injectToken));
+    const resolveFn = injectMetadata.resolveAll == true ? "_resolveAll" : "_resolve";
+    const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
     return (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
   }
-  resolveInjection(token, argument, options, context, chain) {
-    if ((0, import_type_guards.isDefined)(options.forwardRef)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      context.forwardRefQueue.add(() => {
-        const resolved = this._resolve(token, argument, options, context, chain.addToken(token));
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved);
-      });
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    return this._resolve(token, argument, options, context, chain.addToken(token));
+  resolveInjection(token, argument, options, context, injectIndex, chain) {
+    return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
   }
-  async resolveInjectionAsync(token, argument, options, context, chain) {
-    const value = this.resolveInjection(token, argument, options, context, chain);
+  async resolveInjectionAsync(token, argument, options, context, injectIndex, chain) {
+    const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
     await context.$done;
     return value;
   }
-  resolveInjectionAll(token, argument, options, context, chain) {
-    if ((0, import_type_guards.isDefined)(options.forwardRef)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      context.forwardRefQueue.add(() => {
-        const resolved = this._resolveAll(token, argument, options, context, chain.addToken(token));
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved);
-      });
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    return this._resolveAll(token, argument, options, context, chain.addToken(token));
+  resolveInjectionAll(token, argument, options, context, injectIndex, chain) {
+    return this._resolveAll(token, argument, options, context, chain.addInject(token, injectIndex));
   }
-  async resolveInjectionAllAsync(token, argument, options, context, chain) {
-    const values = this.resolveInjectionAll(token, argument, options, context, chain);
+  async resolveInjectionAllAsync(token, argument, options, context, injectIndex, chain) {
+    const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
     await context.$done;
     return values;
   }
@@ -408,13 +401,14 @@ class Injector {
     return context;
   }
   getInjectionContext(resolveContext, resolveArgument, chain) {
+    let injectIndex = 0;
     const context = {
       injector: this,
       argument: resolveArgument,
-      inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, chain),
-      injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, chain),
-      injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, chain),
-      injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, chain)
+      inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+      injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+      injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+      injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain)
     };
     return context;
   }

package/injector/resolve-chain.d.ts

@@ -2,6 +2,7 @@ import type { AbstractConstructor } from '../types.js';
 import type { InjectionToken } from './token.js';
 export type ResolveChainNodeBase<Type extends string> = {
     type: Type;
+    forwardRef?: true;
 };
 export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
     token: InjectionToken;
@@ -20,12 +21,14 @@ export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
 export declare class ResolveChain {
     readonly nodes: readonly ResolveChainNode[];
     get length(): number;
-    constructor(nodes?: ResolveChainNode[]);
+    /** @deprecated internal */
+    constructor(nodes: ResolveChainNode[]);
     static startWith(token: InjectionToken): ResolveChain;
     addToken(token: InjectionToken): ResolveChain;
     addInject(token: InjectionToken, index: number): ResolveChain;
     addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
     addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
+    markAsForwardRef(forwardToken: InjectionToken): ResolveChain;
     format(truncate?: number): string;
     truncate(tokenCount: number): ResolveChain;
 }

package/injector/resolve-chain.js

@@ -29,11 +29,12 @@ class ResolveChain {
   get length() {
     return this.nodes.length;
   }
+  /** @deprecated internal */
   constructor(nodes) {
-    this.nodes = nodes ?? [];
+    this.nodes = nodes;
   }
   static startWith(token) {
-    const chain = new ResolveChain();
+    const chain = new ResolveChain([]);
     return chain.addToken(token);
   }
   addToken(token) {
@@ -52,6 +53,11 @@ class ResolveChain {
     const node = { type: "property", constructor, property, token };
     return new ResolveChain([...this.nodes, node]);
   }
+  markAsForwardRef(forwardToken) {
+    const nodes = [...this.nodes];
+    nodes.push({ ...nodes.pop(), token: forwardToken, forwardRef: true });
+    return new ResolveChain(nodes);
+  }
   format(truncate) {
     let chainString = "";
     const chain = (0, import_type_guards.isDefined)(truncate) ? this.truncate(truncate) : this;
@@ -60,26 +66,30 @@ class ResolveChain {
     }
     for (const node of chain.nodes) {
       const tokenName = (0, import_token.getTokenName)(node.token);
+      const forwardRefPrefix = node.forwardRef ? "ForwardRef::" : "";
       switch (node.type) {
         case "token":
           chainString += `
-    -> ${tokenName}`;
+    -> ${forwardRefPrefix}${tokenName}`;
           break;
         case "inject":
+          chainString += ` => inject(${forwardRefPrefix}${tokenName}) [${node.index + 1}]`;
           chainString += `
-    -> inject(${tokenName}) #${node.index + 1}`;
+    -> ${tokenName}`;
           break;
         case "parameter":
           const metadata = import_reflection.reflectionRegistry.getMetadata(node.constructor);
           const prefix = "_, ".repeat(node.index);
-          const suffix = ", _".repeat((0, import_type_guards.assertDefinedPass)(metadata?.parameters, "missing parameters metadata").length - node.index - 1);
-          chainString += `(${prefix}${tokenName}${suffix})`;
+          const suffix = ", _".repeat((0, import_type_guards.assertDefinedPass)(metadata?.parameters, `missing parameters metadata for ${node.constructor.name}`).length - node.index - 1);
+          chainString += `(${prefix}${forwardRefPrefix}${tokenName}${suffix})`;
+          chainString += `
+    -> ${tokenName}`;
           break;
         case "property":
           const constructorName = (0, import_token.getTokenName)(node.constructor);
           const key = getPropertyKeyString(node.property);
           chainString += `
-    -> ${constructorName}[${key}]: ${tokenName}`;
+    -> ${constructorName}[${key}]: ${forwardRefPrefix}${tokenName}`;
           break;
         default:
           throw new Error(`unknown chain node type ${node.type}`);

package/injector/resolve.error.js

@@ -26,11 +26,12 @@ var import_type_guards = require("../utils/type-guards.js");
 class ResolveError extends import_custom_error.CustomError {
   constructor(message, chain, cause) {
     const causeMessage = (0, import_type_guards.isDefined)(cause) ? `
-  cause: ${cause.message}` : "";
+  cause: ${cause?.message}` : "";
     super({
       message: `${message}${causeMessage}
   chain: ${chain.format(15)}`,
-      cause
+      cause,
+      stack: cause?.stack
     });
   }
 }

package/injector/type-info.d.ts

@@ -1,10 +1,12 @@
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { InjectionToken } from './token.js';
 import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
 export type InjectMetadata = {
     /** token overwrite by inject decorator */
     injectToken?: InjectionToken;
-    /** if defined, resolve the ForwardRefToken using ForwardRef strategy instead resolving the token */
-    forwardRefToken?: ForwardRefInjectionToken;
+    /** if defined, resolve the token or ForwardRefToken using ForwardRef strategy instead of resolving the token directly */
+    forwardRef?: boolean | ForwardRefInjectionToken;
+    forwardRefTypeHint?: ForwardRefTypeHint;
     /** whether injection is optional if token is not registered. Set by optional decorator */
     optional?: boolean;
     /** whether injection should resolve all providers */

package/injector/types.d.ts

@@ -1,6 +1,7 @@
 import type { CancellationSignal } from '../cancellation/index.js';
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { Injector } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
@@ -24,10 +25,13 @@ export type AfterResolveContext<D extends Record> = {
 export type Mapper<T = any, U = unknown> = (value: T) => U;
 export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
 export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
-export type ResolveOptions = {
+export type ResolveOptions<T, A> = {
     optional?: boolean;
     skipSelf?: boolean;
     onlySelf?: boolean;
+    /** If defined, resolve the token using ForwardRef strategy instead of resolving the token directly can be used to circumvent circular dependency problems */
+    forwardRef?: boolean | ForwardRefInjectionToken<T, A>;
+    forwardRefTypeHint?: ForwardRefTypeHint;
 };
 /**
  * data to store between different stages like resolve and afterResolve

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.87.8",
+  "version": "0.87.10",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/object/forward-ref.d.ts

@@ -1,7 +1,10 @@
 declare const isForwardRef: unique symbol;
+export type ForwardRefTypeHint = 'object' | 'function';
 export type ForwardRefOptions<T extends object = object> = {
     reference?: T;
     initializer?: () => T;
+    /** Due to limitations of Proxy, there can be some issues if proxy is created with a target of the "wrong" type. If possible, you should specify the type is forward ref is going to forward to. */
+    typeHint?: ForwardRefTypeHint;
 };
 export type ForwardRef<T extends object = object> = T & {
     [isForwardRef]: true;

package/utils/object/forward-ref.js

@@ -54,8 +54,8 @@ const ForwardRef = {
   }
 };
 function getForwardRefProxy(context) {
-  function forwardRef() {
-  }
+  const target = context.typeHint == "function" ? function forwardRef() {
+  } : { forwardRef: true };
   const handler = {};
   for (const method of import_proxy.reflectMethods) {
     handler[method] = {
@@ -68,7 +68,7 @@ function getForwardRefProxy(context) {
       }
     }[method];
   }
-  return new Proxy(forwardRef, handler);
+  return new Proxy(target, handler);
 }
 function getContext(options) {
   const reference = (0, import_type_guards.isDefined)(options?.reference) ? { value: options?.reference } : (0, import_type_guards.isDefined)(options?.initializer) ? { initializer: options?.initializer } : { value: void 0 };