@tstdl/base 0.87.9 → 0.87.11

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, void 0, { forwardRef: true });
+        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 = {
-    forwardRef: token ?? true
+    forwardRef: token ?? true,
+    forwardRefTypeHint: options?.forwardRefTypeHint
   };
   if ((0, import_type_guards.isDefined)(argument)) {
     injectMetadata.resolveArgumentProvider = () => argument;

package/injector/injector.js

@@ -229,7 +229,7 @@ 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();
+      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);
@@ -359,7 +359,7 @@ class Injector {
       });
     }
     const resolveFn = injectMetadata.resolveAll == true ? "_resolveAll" : "_resolve";
-    const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef }, context, getChain(injectToken));
+    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, injectIndex, chain) {

package/injector/type-info.d.ts

@@ -1,3 +1,4 @@
+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 = {
@@ -5,6 +6,7 @@ export type InjectMetadata = {
     injectToken?: InjectionToken;
     /** 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';
@@ -30,6 +31,7 @@ export type ResolveOptions<T, A> = {
     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.9",
+  "version": "0.87.11",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/text/dynamic-text.model.js

@@ -30,6 +30,7 @@ __export(dynamic_text_model_exports, {
 });
 module.exports = __toCommonJS(dynamic_text_model_exports);
 var import_rxjs = require("rxjs");
+var import_core = require("../core.js");
 var import_inject = require("../injector/inject.js");
 var import_api = require("../signals/api.js");
 var import_switch_map = require("../signals/switch-map.js");
@@ -37,7 +38,7 @@ var import_untracked_operator = require("../signals/untracked-operator.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_localization_service = require("./localization.service.js");
 const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
-function resolveDynamicText(text, localizationService = (0, import_inject.inject)(import_localization_service.LocalizationService)) {
+function resolveDynamicText(text, localizationService = (0, import_inject.inject)(import_localization_service.LocalizationService, void 0, { optional: true }) ?? (0, import_core.getGlobalInjector)().resolve(import_localization_service.LocalizationService)) {
   const localizableTextSignal = (0, import_api.isSignal)(text) ? text : (0, import_rxjs.isObservable)(text) ? (0, import_api.toSignal)(text.pipe((0, import_untracked_operator.runInUntracked)()), { initialValue: missingLocalizationKeyText }) : (0, import_api.computed)(() => text);
   return (0, import_switch_map.switchMap)(() => {
     const localizableText = localizableTextSignal();

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 };