@tstdl/base 0.90.52 → 0.90.54

package/api/client/client.d.ts

@@ -2,7 +2,7 @@ import type { HttpClientOptions } from '../../http/client/index.js';
 import { HttpClient } from '../../http/client/index.js';
 import type { Resolvable } from '../../injector/interfaces.js';
 import type { ApiClientImplementation, ApiDefinition, ApiEndpointDefinition } from '../types.js';
-export type ApiClient<T extends ApiDefinition> = new (httpClient: HttpClient) => ApiClientImplementation<T> & Resolvable<HttpClientOptions>;
+export type ApiClient<T extends ApiDefinition> = new (httpClientOrOptions?: HttpClient | HttpClientOptions) => ApiClientImplementation<T> & Resolvable<HttpClient | HttpClientOptions>;
 export type ClientOptions = {
     /**
      * url prefix

package/authentication/client/api.client.js

@@ -4,11 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import { compileClient } from '../../api/client/index.js';
-import { HttpClient } from '../../http/client/http-client.js';
 import { ReplaceClass, Singleton } from '../../injector/index.js';
 import { emptyObjectSchema } from '../../schema/schemas/object.js';
 import { unknown } from '../../schema/schemas/unknown.js';
@@ -16,13 +12,9 @@ import { getAuthenticationApiDefinition } from '../authentication.api.js';
 export function getAuthenticationApiClient(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetData) {
     const definition = getAuthenticationApiDefinition(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetData);
     let AuthenticationApiClient = class AuthenticationApiClient extends compileClient(definition) {
-        constructor(httpClient) {
-            super(httpClient);
-        }
     };
     AuthenticationApiClient = __decorate([
-        Singleton(),
-        __metadata("design:paramtypes", [HttpClient])
+        Singleton()
     ], AuthenticationApiClient);
     return AuthenticationApiClient;
 }

package/injector/inject.d.ts

@@ -1,3 +1,4 @@
+import type { ResolveManyItem, ResolveManyReturnType } from './injector.js';
 import { Injector } from './injector.js';
 import type { Resolvable, ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
@@ -11,17 +12,13 @@ export type InjectionContext = {
     argument: unknown;
     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[];
+    injectMany<T extends InjectManyItem<any, any>[]>(...tokens: T): InjectManyReturnType<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[]>;
+    injectManyAsync<T extends InjectManyItem<any, any>[]>(...tokens: T): Promise<InjectManyReturnType<T>>;
 };
-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;
-}]) ? undefined : never) : never;
-export type InjectManyReturnType<T extends InjectManyItem<any, any>[]> = {
-    [I in keyof T]: InjectManyItemReturnType<T[I]>;
-};
+export type InjectManyItem<T, A> = ResolveManyItem<T, A>;
+export type InjectManyReturnType<T extends InjectManyItem<any, any>[]> = ResolveManyReturnType<T>;
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *
@@ -82,8 +79,8 @@ export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argume
 export declare function injectArgument<T, R>(_this?: Resolvable<T>, options?: InjectArgumentOptions & {
     optional: R;
 }): T | (R extends true ? undefined : never);
-export declare function getCurrentInjectionContext(required: true): InjectionContext;
-export declare function getCurrentInjectionContext(required?: boolean): InjectionContext | null;
+export declare function getCurrentInjectionContext(debugFn: Function, required: true): InjectionContext;
+export declare function getCurrentInjectionContext(debugFn: Function, required?: boolean): InjectionContext | null;
 export declare function getCurrentInjector(required: true): Injector;
 export declare function getCurrentInjector(required?: boolean): Injector | null;
 export declare function setCurrentInjectionContext(context: InjectionContext | null): InjectionContext | null;

package/injector/inject.js

@@ -1,11 +1,8 @@
-import { mapAsync } from '../utils/async-iterable-helpers/map.js';
-import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
-import { assertDefined, isArray, isNotNull } from '../utils/type-guards.js';
+import { assertDefined, isNotNull } from '../utils/type-guards.js';
 import { Injector } from './injector.js';
 let currentInjectionContext = null;
 export function inject(token, argument, options) {
-    assertInInjectionContext(inject);
-    return currentInjectionContext.inject(token, argument, options);
+    return getCurrentInjectionContext(inject, true).inject(token, argument, options);
 }
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
@@ -13,12 +10,10 @@ export function inject(token, argument, options) {
  * @param token tokens to resolve
  */
 export function injectMany(...tokens) {
-    assertInInjectionContext(inject);
-    return tokens.map((item) => (isArray(item) ? currentInjectionContext.inject(item[0], item[1], item[2]) : currentInjectionContext.inject(item)));
+    return getCurrentInjectionContext(injectMany, true).injectMany(...tokens);
 }
 export async function injectAsync(token, argument, options) {
-    assertInInjectionContext(inject);
-    return currentInjectionContext.injectAsync(token, argument, options);
+    return getCurrentInjectionContext(injectAsync, true).injectAsync(token, argument, options);
 }
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
@@ -26,8 +21,7 @@ export async function injectAsync(token, argument, options) {
  * @param token tokens to resolve
  */
 export async function injectManyAsync(...tokens) {
-    assertInInjectionContext(inject);
-    return toArrayAsync(mapAsync(tokens, async (item) => (isArray(item) ? currentInjectionContext.injectAsync(item[0], item[1], item[2]) : currentInjectionContext.injectAsync(item))));
+    return getCurrentInjectionContext(injectManyAsync, true).injectManyAsync(...tokens);
 }
 /**
  * Resolves a token using the {@link Injector} of the current injection context
@@ -37,8 +31,7 @@ export async function injectManyAsync(...tokens) {
  * @param options resolve options
  */
 export function injectAll(token, argument, options) {
-    assertInInjectionContext(injectAll);
-    return currentInjectionContext.injectAll(token, argument, options);
+    return getCurrentInjectionContext(injectAll, true).injectAll(token, argument, options);
 }
 /**
  * Resolves a token using the {@link Injector} of the current injection context
@@ -48,8 +41,7 @@ export function injectAll(token, argument, options) {
  * @param options resolve options
  */
 export async function injectAllAsync(token, argument, options) {
-    assertInInjectionContext(injectAll);
-    return currentInjectionContext.injectAllAsync(token, argument, options);
+    return getCurrentInjectionContext(injectAllAsync, true).injectAllAsync(token, argument, options);
 }
 /**
  * Injects the resolve argument from the current resolution
@@ -57,21 +49,20 @@ export async function injectAllAsync(token, argument, options) {
  * @returns
  */
 export function injectArgument(_this, options) {
-    assertInInjectionContext(injectArgument);
-    const argument = currentInjectionContext.argument;
+    const argument = getCurrentInjectionContext(injectArgument, true).argument;
     if (options?.optional != true) {
         assertDefined(argument, 'No resolve argument available in current injection context.');
     }
     return argument;
 }
-export function getCurrentInjectionContext(required = false) {
+export function getCurrentInjectionContext(debugFn, required = false) {
     if (required) {
-        assertInInjectionContext(getCurrentInjector);
+        assertInInjectionContext(debugFn);
     }
     return currentInjectionContext;
 }
 export function getCurrentInjector(required = false) {
-    return getCurrentInjectionContext(required)?.injector ?? null;
+    return getCurrentInjectionContext(getCurrentInjector, required)?.injector ?? null;
 }
 export function setCurrentInjectionContext(context) {
     const previous = currentInjectionContext;
@@ -92,8 +83,10 @@ export function runInInjectionContext(injectorOrContext, fn) {
             argument: undefined,
             inject(token, argument, options) { return injectorOrContext.resolve(token, argument, options); },
             injectAll(token, argument, options) { return injectorOrContext.resolveAll(token, argument, options); },
+            injectMany(...tokens) { return injectorOrContext.resolveMany(...tokens); },
             async injectAsync(token, argument, options) { return injectorOrContext.resolveAsync(token, argument, options); },
-            async injectAllAsync(token, argument, options) { return injectorOrContext.resolveAllAsync(token, argument, options); }
+            async injectAllAsync(token, argument, options) { return injectorOrContext.resolveAllAsync(token, argument, options); },
+            async injectManyAsync(...tokens) { return injectorOrContext.resolveManyAsync(...tokens); },
         }
         : injectorOrContext;
     const previousContext = setCurrentInjectionContext(context);

package/injector/injector.d.ts

@@ -1,5 +1,6 @@
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import type { OneOrMany, Record, TypedOmit } from '../types.js';
+import type { InjectOptions } from './inject.js';
 import type { ResolveArgument } from './interfaces.js';
 import { type Provider } from './provider.js';
 import { type InjectionToken } from './token.js';
@@ -16,6 +17,14 @@ export type GetRegistrationOptions = {
     skipSelf?: boolean;
     onlySelf?: boolean;
 };
+export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
+export type ResolveManyItem<T, A> = InjectionToken<T, A> | ResolveManyArrayItem<T, A>;
+export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T extends ResolveManyItem<infer U, any> ? U | (T extends (ResolveManyArrayItem<any, any> & [any, any, {
+    optional: true;
+}]) ? undefined : never) : never;
+export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = {
+    [I in keyof T]: ResolveManyItemReturnType<T[I]>;
+};
 export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
 export declare class Injector implements AsyncDisposable {
     #private;
@@ -73,11 +82,13 @@ export declare class Injector implements AsyncDisposable {
     }): T | undefined;
     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[];
+    resolveMany<T extends ResolveManyItem<any, any>[]>(...tokens: T): ResolveManyReturnType<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<T, A>): Promise<T>;
     resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
+    resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>>;
     private _resolve;
     private _resolveAll;
     private _resolveRegistration;

package/injector/injector.js

@@ -166,6 +166,15 @@ export class Injector {
         context.$done.resolve();
         return values;
     }
+    resolveMany(...tokens) {
+        const context = newInternalResolveContext();
+        const values = tokens.map((token) => (isArray(token)
+            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(token[0]))
+            : this._resolve(token, undefined, {}, context, ResolveChain.startWith(token))));
+        postProcess(context);
+        context.$done.resolve();
+        return values;
+    }
     async resolveAsync(token, argument, options = {}) {
         const context = newInternalResolveContext();
         const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
@@ -180,6 +189,15 @@ export class Injector {
         context.$done.resolve();
         return values;
     }
+    async resolveManyAsync(...tokens) {
+        const context = newInternalResolveContext();
+        const values = tokens.map((token) => (isArray(token)
+            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(token[0]))
+            : this._resolve(token, undefined, {}, context, ResolveChain.startWith(token))));
+        await postProcessAsync(context);
+        context.$done.resolve();
+        return values;
+    }
     _resolve(token, argument, options, context, chain) {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
@@ -237,7 +255,7 @@ export class Injector {
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
         const resolutionTag = Symbol(); // eslint-disable-line symbol-description
         try {
-            const token = registration.token;
+            const { token } = registration;
             const resolutionScoped = registration.options.lifecycle == 'resolution';
             const injectorScoped = registration.options.lifecycle == 'injector';
             const singletonScoped = registration.options.lifecycle == 'singleton';
@@ -280,7 +298,7 @@ export class Injector {
     _resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain) {
         try {
             setResolving(registration.token, context, chain);
-            const provider = registration.provider;
+            const { provider } = registration;
             let result;
             if (isClassProvider(provider)) {
                 const typeMetadata = reflectionRegistry.getMetadata(provider.useClass);
@@ -343,7 +361,7 @@ export class Injector {
             return injectMetadata.injectArgumentMapper(resolveArgument);
         }
         const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
-        const forwardRef = injectMetadata.forwardRef;
+        const { forwardRef } = injectMetadata;
         if (isDefined(forwardRef)) {
             context.forwardRefQueue.add(() => {
                 const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
@@ -401,8 +419,10 @@ export class Injector {
             argument: resolveArgument,
             inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectMany: (...tokens) => this.resolveMany(...tokens),
             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)
+            injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectManyAsync: async (...tokens) => this.resolveManyAsync(...tokens)
         };
         return context;
     }

package/injector/resolve.error.js

@@ -2,7 +2,7 @@ import { CustomError } from '../errors/custom.error.js';
 import { isDefined } from '../utils/type-guards.js';
 export class ResolveError extends CustomError {
     constructor(message, chain, cause) {
-        const causeMessage = isDefined(cause) ? `\n  cause: ${cause?.message}` : '';
+        const causeMessage = isDefined(cause) ? `\n  cause: ${cause.message}` : '';
         super({
             message: `${message}${causeMessage}\n  chain: ${chain.format(15)}`,
             cause,

package/package.json

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