@tstdl/base 0.85.14 → 0.85.16

package/injector/inject.d.ts

@@ -0,0 +1,80 @@
+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 InjectArgumentOptions = {
+    optional?: boolean;
+};
+export type InjectionContext = {
+    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[]>;
+};
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @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 & {
+    optional: true;
+}): T | undefined;
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @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 & {
+    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>;
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @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[];
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @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[]>;
+/**
+ * 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}.
+ * @returns
+ */
+export declare function injectArgument<T, R>(_this?: Resolvable<T>, options?: InjectArgumentOptions & {
+    optional: R;
+}): T | (R extends true ? undefined : never);
+export declare function getCurrentInjectionContext(): InjectionContext | null;
+export declare function setCurrentInjectionContext(context: InjectionContext | null): InjectionContext | null;
+/**
+ * Runs the given function in the context of the given {@link InjectionContext}.
+ *
+ * @param context the injection context which will satisfy calls to {@link inject} while `fn` is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ */
+export declare function runInInjectionContext<ReturnT>(injectorOrContext: Injector | InjectionContext, fn: () => ReturnT): ReturnT;
+/**
+ * Asserts that the current stack frame is within an injection context and has access to {@link inject}.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ */
+export declare function assertInInjectionContext(debugFn: Function): void;

package/injector/inject.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inject_exports = {};
+__export(inject_exports, {
+  assertInInjectionContext: () => assertInInjectionContext,
+  getCurrentInjectionContext: () => getCurrentInjectionContext,
+  inject: () => inject,
+  injectAll: () => injectAll,
+  injectAllAsync: () => injectAllAsync,
+  injectArgument: () => injectArgument,
+  injectAsync: () => injectAsync,
+  runInInjectionContext: () => runInInjectionContext,
+  setCurrentInjectionContext: () => setCurrentInjectionContext
+});
+module.exports = __toCommonJS(inject_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_injector = require("./injector.js");
+let currentInjectionContext = null;
+function inject(token, argument, options) {
+  assertInInjectionContext(inject);
+  return currentInjectionContext.inject(token, argument, options);
+}
+async function injectAsync(token, argument, options) {
+  assertInInjectionContext(inject);
+  return currentInjectionContext.injectAsync(token, argument, options);
+}
+function injectAll(token, argument, options) {
+  assertInInjectionContext(injectAll);
+  return currentInjectionContext.injectAll(token, argument, options);
+}
+async function injectAllAsync(token, argument, options) {
+  assertInInjectionContext(injectAll);
+  return currentInjectionContext.injectAllAsync(token, argument, options);
+}
+function injectArgument(_this, options) {
+  assertInInjectionContext(injectArgument);
+  const argument = currentInjectionContext.argument;
+  if (options?.optional != true) {
+    (0, import_type_guards.assertDefined)(argument, "No resolve argument available in current injection context.");
+  }
+  return argument;
+}
+function getCurrentInjectionContext() {
+  return currentInjectionContext;
+}
+function setCurrentInjectionContext(context) {
+  const previous = currentInjectionContext;
+  currentInjectionContext = context;
+  return previous;
+}
+function runInInjectionContext(injectorOrContext, fn) {
+  const context = injectorOrContext instanceof import_injector.Injector ? {
+    argument: void 0,
+    inject(token, argument, options) {
+      return injectorOrContext.resolve(token, argument, options);
+    },
+    injectAll(token, argument, options) {
+      return injectorOrContext.resolveAll(token, argument, options);
+    },
+    async injectAsync(token, argument, options) {
+      return injectorOrContext.resolveAsync(token, argument, options);
+    },
+    async injectAllAsync(token, argument, options) {
+      return injectorOrContext.resolveAllAsync(token, argument, options);
+    }
+  } : injectorOrContext;
+  const previousContext = setCurrentInjectionContext(context);
+  try {
+    return fn();
+  } finally {
+    setCurrentInjectionContext(previousContext);
+  }
+}
+function assertInInjectionContext(debugFn) {
+  if ((0, import_type_guards.isNull)(currentInjectionContext)) {
+    throw new Error(`${debugFn.name}() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\``);
+  }
+}

package/injector/injector.d.ts

@@ -0,0 +1,111 @@
+import { CircularBuffer } from '../data-structures/circular-buffer.js';
+import { MultiKeyMap } from '../data-structures/multi-key-map.js';
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import type { TypedOmit } from '../types.js';
+import { ForwardRef } from '../utils/object/forward-ref.js';
+import type { ResolveArgument } from './interfaces.js';
+import { type Provider } from './provider.js';
+import { ResolveChain } from './resolve-chain.js';
+import { type InjectionToken } from './token.js';
+import type { RegistrationOptions, ResolveOptions } from './types.js';
+type InternalResolveContext = {
+    resolves: number;
+    /** Currently resolving tokens (for circular dependency detection) */
+    resolving: Set<InjectionToken>;
+    /** resolutions for resolution scoped dependencies  */
+    resolutionScopedResolutions: MultiKeyMap<[InjectionToken, unknown], Resolution<any, any>>;
+    /** all resolutions in this chain for postprocessing */
+    resolutions: Resolution<any, any>[];
+    forwardRefQueue: CircularBuffer<(() => void | Promise<void>)>;
+    forwardRefs: Set<ForwardRef>;
+    $done: DeferredPromise;
+};
+type Resolution<T, A> = {
+    registration: Registration<T>;
+    value: T;
+    argument: ResolveArgument<T, A>;
+    chain: ResolveChain;
+};
+export type GlobalRegistration<T = any, A = any> = {
+    token: InjectionToken<T, A>;
+    provider: Provider<T, A>;
+    options: RegistrationOptions<T, A>;
+};
+export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
+    resolutions: Map<any, T>;
+};
+export type GetRegistrationOptions = {
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+};
+export declare class Injector {
+    #private;
+    readonly name: string;
+    constructor(name: string, parent?: Injector | null);
+    /**
+     * Register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static registerGlobal<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
+    /**
+     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static registerGlobalSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
+    fork(name: string): Injector;
+    /**
+     * Register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
+    /**
+     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    registerSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
+    /**
+     * Check if token has a registered provider
+     * @param token token check
+     */
+    hasRegistration(token: InjectionToken, options?: GetRegistrationOptions): boolean;
+    /**
+     * Try to get registration
+     * @param token token to get registration for
+     */
+    tryGetRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[] | undefined;
+    /**
+     * Get registration
+     * @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 & {
+        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 & {
+        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[]>;
+    _resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T | undefined;
+    _resolveAll<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T[];
+    _resolveRegistration<T, A>(registration: Registration<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T;
+    _resolveProvider<T, A>(registration: Registration<T, A>, resolveArgument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T;
+    private resolveClassInjection;
+    private resolveInjection;
+    private resolveInjectionAsync;
+    private resolveInjectionAll;
+    private resolveInjectionAllAsync;
+    private getResolveContext;
+    private getInjectionContext;
+}
+export {};