@lppedd/di-wise-neo 0.3.0 → 0.3.2

package/src/defaultContainer.ts

@@ -1,519 +0,0 @@
-import type { Container, ContainerOptions } from "./container";
-import { assert, expectNever, throwExistingUnregisteredError, throwUnregisteredError } from "./errors";
-import { injectBy } from "./inject";
-import { injectAll } from "./injectAll";
-import { createResolution, provideInjectionContext, useInjectionContext } from "./injectionContext";
-import { getMetadata } from "./metadata";
-import { optionalBy } from "./optional";
-import { optionalAll } from "./optionalAll";
-import {
-  isClassProvider,
-  isExistingProvider,
-  isFactoryProvider,
-  isValueProvider,
-  type Provider,
-} from "./provider";
-import { Scope } from "./scope";
-import { type Constructor, isConstructor, type Token } from "./token";
-import { isBuilder, type Registration, type RegistrationOptions, TokenRegistry } from "./tokenRegistry";
-import { isDisposable } from "./utils/disposable";
-
-/**
- * The default implementation of a di-wise-neo {@link Container}.
- */
-export class DefaultContainer implements Container {
-  // eslint-disable-next-line no-use-before-define
-  private readonly myChildren: Set<DefaultContainer> = new Set();
-  private readonly myOptions: ContainerOptions;
-  private readonly myTokenRegistry: TokenRegistry;
-  private myDisposed: boolean = false;
-
-  constructor(
-    private readonly myParent: DefaultContainer | undefined,
-    options: Partial<ContainerOptions>,
-  ) {
-    this.myOptions = {
-      autoRegister: false,
-      defaultScope: Scope.Inherited,
-      ...options,
-    };
-
-    this.myTokenRegistry = new TokenRegistry(this.myParent?.myTokenRegistry);
-  }
-
-  get registry(): TokenRegistry {
-    return this.myTokenRegistry;
-  }
-
-  get options(): ContainerOptions {
-    return {
-      ...this.myOptions,
-    };
-  }
-
-  get parent(): Container | undefined {
-    return this.myParent;
-  }
-
-  get isDisposed(): boolean {
-    return this.myDisposed;
-  }
-
-  createChild(options?: Partial<ContainerOptions>): Container {
-    this.checkDisposed();
-    const container = new DefaultContainer(this, {
-      ...this.myOptions,
-      ...options,
-    });
-
-    this.myChildren.add(container);
-    return container;
-  }
-
-  clearCache(): unknown[] {
-    this.checkDisposed();
-    return this.myTokenRegistry.clearRegistrations();
-  }
-
-  getCached<T>(token: Token<T>): T | undefined {
-    this.checkDisposed();
-    const registration = this.myTokenRegistry.get(token);
-    return registration?.value?.current;
-  }
-
-  getAllCached<T>(token: Token<T>): T[] {
-    this.checkDisposed();
-    const registrations = this.myTokenRegistry.getAll(token);
-
-    if (!registrations) {
-      return [];
-    }
-
-    const values = new Set<T>();
-
-    for (const registration of registrations) {
-      const value = registration.value;
-
-      if (value) {
-        values.add(value.current);
-      }
-    }
-
-    return Array.from(values);
-  }
-
-  resetRegistry(): unknown[] {
-    this.checkDisposed();
-    const [, registrations] = this.myTokenRegistry.deleteAll();
-    const values = new Set<unknown>();
-
-    for (const registration of registrations) {
-      const value = registration.value;
-
-      if (value) {
-        values.add(value.current);
-      }
-    }
-
-    return Array.from(values);
-  }
-
-  isRegistered(token: Token): boolean {
-    this.checkDisposed();
-    return this.myTokenRegistry.get(token) !== undefined;
-  }
-
-  register<T>(...args: [Constructor<T & object>] | [Token<T>, Provider<T>, RegistrationOptions?]): this {
-    this.checkDisposed();
-
-    if (args.length == 1) {
-      const Class = args[0];
-      const metadata = getMetadata(Class);
-
-      // Register the class itself
-      this.myTokenRegistry.set(Class, {
-        // The provider is of type ClassProvider, initialized by getMetadata
-        provider: metadata.provider,
-        options: {
-          scope: metadata.scope,
-        },
-        dependencies: metadata.dependencies,
-      });
-
-      // Register the additional tokens specified via class decorators.
-      // These tokens will point to the original Class token and will have the same scope.
-      for (const token of metadata.tokensRef.getRefTokens()) {
-        this.myTokenRegistry.set(token, {
-          provider: {
-            useExisting: Class,
-          },
-        });
-      }
-    } else {
-      const [token, provider, options] = args;
-
-      if (isClassProvider(provider)) {
-        const Class = provider.useClass;
-        const metadata = getMetadata(Class);
-        this.myTokenRegistry.set(token, {
-          provider: metadata.provider,
-          options: {
-            // The explicit registration options override what is specified
-            // via class decorators (e.g., @Scoped)
-            scope: metadata.scope,
-            ...options,
-          },
-          dependencies: metadata.dependencies,
-        });
-      } else {
-        if (isExistingProvider(provider)) {
-          assert(
-            token !== provider.useExisting,
-            `the useExisting token ${token.name} cannot be the same as the token being registered`,
-          );
-        }
-
-        this.myTokenRegistry.set(token, {
-          provider: provider,
-          options: options,
-        });
-      }
-    }
-
-    return this;
-  }
-
-  unregister<T>(token: Token<T>): T[] {
-    this.checkDisposed();
-    const registrations = this.myTokenRegistry.delete(token);
-
-    if (!registrations) {
-      return [];
-    }
-
-    const values = new Set<T>();
-
-    for (const registration of registrations) {
-      const value = registration.value;
-
-      if (value) {
-        values.add(value.current);
-      }
-    }
-
-    return Array.from(values);
-  }
-
-  resolve<T>(token: Token<T>, optional?: boolean): T | undefined {
-    this.checkDisposed();
-    const registration = this.myTokenRegistry.get(token);
-
-    if (registration) {
-      return this.resolveRegistration(token, registration);
-    }
-
-    if (isConstructor(token)) {
-      return this.instantiateClass(token, optional);
-    }
-
-    return optional ? undefined : throwUnregisteredError(token);
-  }
-
-  resolveAll<T>(token: Token<T>, optional?: boolean): NonNullable<T>[] {
-    this.checkDisposed();
-    const registrations = this.myTokenRegistry.getAll(token);
-
-    if (registrations) {
-      return registrations
-        .map((registration) => this.resolveRegistration(token, registration))
-        .filter((value) => value != null);
-    }
-
-    if (isConstructor(token)) {
-      const instance = this.instantiateClass(token, optional);
-      return instance === undefined // = could not resolve, but since it is optional
-        ? []
-        : [instance];
-    }
-
-    return optional ? [] : throwUnregisteredError(token);
-  }
-
-  dispose(): void {
-    if (this.myDisposed) {
-      return;
-    }
-
-    // Dispose children containers first
-    for (const child of this.myChildren) {
-      child.dispose();
-    }
-
-    this.myChildren.clear();
-
-    // Remove ourselves from our parent container
-    this.myParent?.myChildren?.delete(this);
-    this.myDisposed = true;
-
-    const [, registrations] = this.myTokenRegistry.deleteAll();
-    const disposedRefs = new Set<any>();
-
-    // Dispose all resolved (aka instantiated) tokens that implement the Disposable interface
-    for (const registration of registrations) {
-      const value = registration.value?.current;
-
-      if (isDisposable(value) && !disposedRefs.has(value)) {
-        disposedRefs.add(value);
-        value.dispose();
-      }
-    }
-
-    // Allow values to be GCed
-    disposedRefs.clear();
-  }
-
-  private resolveRegistration<T>(token: Token<T>, registration: Registration<T>): T {
-    let currRegistration: Registration<T> | undefined = registration;
-    let currProvider = currRegistration.provider;
-
-    while (isExistingProvider(currProvider)) {
-      const targetToken = currProvider.useExisting;
-      currRegistration = this.myTokenRegistry.get(targetToken);
-
-      if (!currRegistration) {
-        throwExistingUnregisteredError(token, targetToken);
-      }
-
-      currProvider = currRegistration.provider;
-    }
-
-    try {
-      return this.resolveProviderValue(currRegistration, currProvider);
-    } catch (e) {
-      // If we were trying to resolve a token registered via ExistingProvider,
-      // we must add the cause of the error to the message
-      if (isExistingProvider(registration.provider)) {
-        throwExistingUnregisteredError(token, e as Error);
-      }
-
-      throw e;
-    }
-  }
-
-  private instantiateClass<T extends object>(Class: Constructor<T>, optional?: boolean): T | undefined {
-    const metadata = getMetadata(Class);
-
-    if (metadata.autoRegister ?? this.myOptions.autoRegister) {
-      this.register(Class);
-      return (this as Container).resolve(Class);
-    }
-
-    const scope = this.resolveScope(metadata.scope);
-
-    if (optional && scope === Scope.Container) {
-      // It would not be possible to resolve the class in container scope,
-      // as that would require prior registration.
-      // However, since resolution is marked optional, we simply return undefined.
-      return undefined;
-    }
-
-    assert(
-      scope !== Scope.Container,
-      `unregistered class ${Class.name} cannot be resolved in container scope`,
-    );
-
-    const registration: Registration<T> = {
-      provider: metadata.provider,
-      options: {
-        scope: scope,
-      },
-      dependencies: metadata.dependencies,
-    };
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    return this.resolveScopedValue(registration, (args) => new Class(...args));
-  }
-
-  private resolveProviderValue<T>(registration: Registration<T>, provider: Provider<T>): T {
-    assert(registration.provider === provider, "internal error: mismatching provider");
-
-    if (isClassProvider(provider)) {
-      const Class = provider.useClass;
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      return this.resolveScopedValue(registration, (args) => new Class(...args));
-    }
-
-    if (isFactoryProvider(provider)) {
-      const factory = provider.useFactory;
-      return this.resolveScopedValue(registration, factory);
-    }
-
-    if (isValueProvider(provider)) {
-      return provider.useValue;
-    }
-
-    if (isExistingProvider(provider)) {
-      assert(false, "internal error: unexpected ExistingProvider");
-    }
-
-    expectNever(provider);
-  }
-
-  private resolveScopedValue<T>(registration: Registration<T>, factory: (...args: any[]) => T): T {
-    let context = useInjectionContext();
-
-    if (!context || context.container !== this) {
-      context = {
-        container: this,
-        resolution: createResolution(),
-      };
-    }
-
-    const resolution = context.resolution;
-    const provider = registration.provider;
-    const options = registration.options;
-
-    if (resolution.stack.has(provider)) {
-      const dependentRef = resolution.dependents.get(provider);
-      assert(dependentRef, "circular dependency detected");
-      return dependentRef.current;
-    }
-
-    const scope = this.resolveScope(options?.scope, context);
-    const cleanups = [
-      provideInjectionContext(context),
-      !isBuilder(provider) && resolution.stack.push(provider, { provider, scope }),
-    ];
-
-    try {
-      switch (scope) {
-        case Scope.Container: {
-          const valueRef = registration.value;
-
-          if (valueRef) {
-            return valueRef.current;
-          }
-
-          const args = this.resolveConstructorDependencies(registration);
-          const value = this.injectDependencies(registration, factory(args));
-          registration.value = { current: value };
-          return value;
-        }
-        case Scope.Resolution: {
-          const valueRef = resolution.values.get(provider);
-
-          if (valueRef) {
-            return valueRef.current;
-          }
-
-          const args = this.resolveConstructorDependencies(registration);
-          const value = this.injectDependencies(registration, factory(args));
-          resolution.values.set(provider, { current: value });
-          return value;
-        }
-        case Scope.Transient: {
-          const args = this.resolveConstructorDependencies(registration);
-          return this.injectDependencies(registration, factory(args));
-        }
-      }
-    } finally {
-      cleanups.forEach((cleanup) => cleanup && cleanup());
-    }
-  }
-
-  private resolveScope(
-    scope = this.myOptions.defaultScope,
-    context = useInjectionContext(),
-  ): Exclude<Scope, typeof Scope.Inherited> {
-    if (scope == Scope.Inherited) {
-      const dependentFrame = context?.resolution.stack.peek();
-      return dependentFrame?.scope || Scope.Transient;
-    }
-
-    return scope;
-  }
-
-  private resolveConstructorDependencies<T>(registration: Registration<T>): any[] {
-    const dependencies = registration.dependencies;
-
-    if (dependencies) {
-      assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
-      const ctorDeps = dependencies.constructor;
-
-      if (ctorDeps.length > 0) {
-        // Let's check if all necessary constructor parameters are decorated.
-        // If not, we cannot safely create an instance.
-        const ctor = registration.provider.useClass;
-        assert(ctor.length === ctorDeps.length, () => {
-          const msg = `expected ${ctor.length} decorated constructor parameters in ${ctor.name}`;
-          return msg + `, but found ${ctorDeps.length}`;
-        });
-
-        return ctorDeps
-          .sort((a, b) => a.index - b.index)
-          .map((dep) => {
-            const token = dep.tokenRef.getRefToken();
-            switch (dep.decorator) {
-              case "Inject":
-                return this.resolve(token);
-              case "InjectAll":
-                return this.resolveAll(token);
-              case "Optional":
-                return this.resolve(token, true);
-              case "OptionalAll":
-                return this.resolveAll(token, true);
-            }
-          });
-      }
-    }
-
-    return [];
-  }
-
-  private injectDependencies<T>(registration: Registration<T>, instance: T): T {
-    const dependencies = registration.dependencies;
-
-    if (dependencies) {
-      assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
-      const ctor = registration.provider.useClass;
-
-      // Perform method injection
-      for (const [key, methodDeps] of dependencies.methods) {
-        // Let's check if all necessary method parameters are decorated.
-        // If not, we cannot safely invoke the method.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const method = (instance as any)[key] as Function;
-        assert(methodDeps.length === method.length, () => {
-          const msg = `expected ${method.length} decorated method parameters`;
-          return msg + ` in ${ctor.name}.${String(key)}, but found ${methodDeps.length}`;
-        });
-
-        const args = methodDeps
-          .sort((a, b) => a.index - b.index)
-          .map((dep) => {
-            const token = dep.tokenRef.getRefToken();
-            switch (dep.decorator) {
-              case "Inject":
-                return injectBy(instance, token);
-              case "InjectAll":
-                return injectAll(token);
-              case "Optional":
-                return optionalBy(instance, token);
-              case "OptionalAll":
-                return optionalAll(token);
-            }
-          });
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        method.bind(instance)(...args);
-      }
-    }
-
-    return instance;
-  }
-
-  private checkDisposed(): void {
-    assert(!this.myDisposed, "the container is disposed");
-  }
-}

package/src/errors.ts

@@ -1,47 +0,0 @@
-import type { Token } from "./token";
-
-// @internal
-export function assert(condition: unknown, message: string | (() => string)): asserts condition {
-  if (!condition) {
-    const resolvedMessage = typeof message === "string" ? message : message();
-    throw new Error(tag(resolvedMessage));
-  }
-}
-
-// @internal
-export function expectNever(value: never): never {
-  throw new TypeError(tag(`unexpected value ${String(value)}`));
-}
-
-// @internal
-export function throwUnregisteredError(token: Token): never {
-  throw new Error(tag(`unregistered token ${token.name}`));
-}
-
-// @internal
-export function throwExistingUnregisteredError(sourceToken: Token, targetTokenOrError: Token | Error): never {
-  let message = tag(`token resolution error encountered while resolving ${sourceToken.name}`);
-
-  if (isError(targetTokenOrError)) {
-    message += `\n  [cause] ${untag(targetTokenOrError.message)}`;
-  } else {
-    message += `\n  [cause] the aliased token ${targetTokenOrError.name} is not registered`;
-  }
-
-  throw new Error(message);
-}
-
-function isError(value: any): value is Error {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  return value && value.stack && value.message && typeof value.message === "string";
-}
-
-function tag(message: string): string {
-  return `[di-wise-neo] ${message}`;
-}
-
-function untag(message: string): string {
-  return message.startsWith("[di-wise-neo]") //
-    ? message.substring(13).trimStart()
-    : message;
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export type { Container, ContainerOptions } from "./container";
-export { createContainer } from "./container";
-export { AutoRegister, Inject, Injectable, InjectAll, Optional, OptionalAll, Scoped } from "./decorators";
-export { inject, injectBy } from "./inject";
-export { injectAll } from "./injectAll";
-export { Injector } from "./injector";
-export type { Middleware, MiddlewareComposer } from "./middleware";
-export { applyMiddleware } from "./middleware";
-export type { ClassProvider, ExistingProvider, FactoryProvider, Provider, ValueProvider } from "./provider";
-export { Scope } from "./scope";
-export type { Constructor, Token, Tokens } from "./token";
-export { Type } from "./token";
-export type { RegistrationOptions } from "./tokenRegistry";
-export { Build } from "./tokenRegistry";
-export type { TokenRef, TokensRef } from "./tokensRef";
-export { forwardRef } from "./tokensRef";

package/src/inject.ts

@@ -1,88 +0,0 @@
-import { ensureInjectionContext } from "./injectionContext";
-import type { Constructor, Token } from "./token";
-
-/**
- * Injects the instance associated with the given class.
- *
- * Throws an error if the class is not registered in the container.
- */
-export function inject<Instance extends object>(Class: Constructor<Instance>): Instance;
-
-/**
- * Injects the value associated with the given token.
- *
- * Throws an error if the token is not registered in the container.
- */
-export function inject<Value>(token: Token<Value>): Value;
-
-export function inject<T>(token: Token<T>): T {
-  const context = ensureInjectionContext(inject);
-  return context.container.resolve(token);
-}
-
-/**
- * Injects the instance associated with the given class.
- *
- * Throws an error if the class is not registered in the container.
- *
- * Compared to {@link inject}, `injectBy` accepts a `thisArg` argument
- * (the containing class) which is used to resolve circular dependencies.
- *
- * @example
- * ```ts
- * class Wand {
- *   owner = inject(Wizard);
- * }
- *
- * class Wizard {
- *   wand = injectBy(this, Wand);
- * }
- * ```
- *
- * @param thisArg - The containing instance, used to help resolve circular dependencies.
- * @param Class - The class to resolve.
- */
-export function injectBy<Instance extends object>(thisArg: any, Class: Constructor<Instance>): Instance;
-
-/**
- * Injects the value associated with the given token.
- *
- * Throws an error if the token is not registered in the container.
- *
- * Compared to {@link inject}, `injectBy` accepts a `thisArg` argument
- * (the containing class) which is used to resolve circular dependencies.
- *
- * @example
- * ```ts
- * class Wand {
- *   owner = inject(Wizard);
- * }
- *
- * class Wizard {
- *   wand = injectBy(this, Wand);
- * }
- * ```
- *
- * @param thisArg - The containing instance, used to help resolve circular dependencies.
- * @param token - The token to resolve.
- */
-export function injectBy<Value>(thisArg: any, token: Token<Value>): Value;
-
-export function injectBy<T>(thisArg: any, token: Token<T>): T {
-  const context = ensureInjectionContext(injectBy);
-  const resolution = context.resolution;
-  const currentFrame = resolution.stack.peek();
-
-  if (!currentFrame) {
-    return inject(token);
-  }
-
-  const currentRef = { current: thisArg };
-  const cleanup = resolution.dependents.set(currentFrame.provider, currentRef);
-
-  try {
-    return inject(token);
-  } finally {
-    cleanup();
-  }
-}

package/src/injectAll.ts

@@ -1,21 +0,0 @@
-import { ensureInjectionContext } from "./injectionContext";
-import type { Constructor, Token } from "./token";
-
-/**
- * Injects all instances provided by the registrations associated with the given class.
- *
- * Throws an error if the class is not registered in the container.
- */
-export function injectAll<Instance extends object>(Class: Constructor<Instance>): Instance[];
-
-/**
- * Injects all values provided by the registrations associated with the given token.
- *
- * Throws an error if the token is not registered in the container.
- */
-export function injectAll<Value>(token: Token<Value>): NonNullable<Value>[];
-
-export function injectAll<T>(token: Token<T>): NonNullable<T>[] {
-  const context = ensureInjectionContext(injectAll);
-  return context.container.resolveAll(token);
-}