@tstdl/base 0.85.26 → 0.86.0-beta10

package/authentication/server/mongo/mongo-authentication-session.repository.d.ts

@@ -1,14 +1,14 @@
-import type { Injectable } from '../../../container/index.js';
-import { type resolveArgumentType } from '../../../container/index.js';
 import type { CollectionArgument } from '../../../database/mongo/index.js';
 import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { Resolvable } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import type { AuthenticationSession, NewAuthenticationSession } from '../../models/index.js';
 import type { AuthenticationSessionExtendData } from '../authentication-session.repository.js';
 import { AuthenticationSessionRepository } from '../authentication-session.repository.js';
 export type MongoAuthenticationSessionRepositoryConfig = MongoAuthenticationSessionRepositoryArgument;
 export type MongoAuthenticationSessionRepositoryArgument = CollectionArgument<AuthenticationSession>;
-export declare class InternalMongoAuthenticationSessionRepository extends MongoEntityRepository<AuthenticationSession> implements Injectable<MongoAuthenticationSessionRepositoryArgument> {
+export declare class InternalMongoAuthenticationSessionRepository extends MongoEntityRepository<AuthenticationSession> implements Resolvable<MongoAuthenticationSessionRepositoryArgument> {
     readonly [resolveArgumentType]: MongoAuthenticationSessionRepositoryArgument;
     constructor(collection: Collection<AuthenticationSession>, logger: Logger);
 }

package/authentication/server/mongo/mongo-authentication-session.repository.js

@@ -23,8 +23,8 @@ __export(mongo_authentication_session_repository_exports, {
   configureMongoAuthenticationSessionRepository: () => configureMongoAuthenticationSessionRepository
 });
 module.exports = __toCommonJS(mongo_authentication_session_repository_exports);
-var import_container = require("../../../container/index.js");
 var import_mongo = require("../../../database/mongo/index.js");
+var import_injector = require("../../../injector/index.js");
 var import_logger = require("../../../logger/index.js");
 var import_authentication_session_repository = require("../authentication-session.repository.js");
 var __decorate = function(decorators, target, key, desc) {
@@ -54,10 +54,10 @@ let InternalMongoAuthenticationSessionRepository = class InternalMongoAuthentica
   }
 };
 InternalMongoAuthenticationSessionRepository = __decorate([
-  (0, import_container.singleton)({
+  (0, import_injector.Singleton)({
     defaultArgumentProvider: () => defaultArgument
   }),
-  __param(0, (0, import_container.forwardArg)()),
+  __param(0, (0, import_injector.ForwardArg)()),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], InternalMongoAuthenticationSessionRepository);
 let MongoAuthenticationSessionRepository = class MongoAuthenticationSessionRepository2 extends import_authentication_session_repository.AuthenticationSessionRepository {
@@ -85,7 +85,7 @@ let MongoAuthenticationSessionRepository = class MongoAuthenticationSessionRepos
   }
 };
 MongoAuthenticationSessionRepository = __decorate([
-  (0, import_container.singleton)(),
+  (0, import_injector.Singleton)(),
   __metadata("design:paramtypes", [InternalMongoAuthenticationSessionRepository])
 ], MongoAuthenticationSessionRepository);
 function configureMongoAuthenticationSessionRepository(config) {

package/browser/browser-context-controller.d.ts

@@ -1,8 +1,8 @@
 import type { BrowserContext } from 'playwright';
-import type { Injectable } from '../container/interfaces.js';
-import { resolveArgumentType } from '../container/interfaces.js';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
+import type { Resolvable } from '../injector/interfaces.js';
+import { resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
 import type { Opaque } from 'type-fest';
@@ -18,10 +18,10 @@ export type NewPageOptions = {
 };
 export type BrowserContextState = Opaque<Record<string | number, unknown>, 'BrowserContextState'>;
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
-export declare class BrowserContextController implements AsyncDisposable, Injectable<BrowserContextControllerArgument> {
-    private readonly options;
+export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
     /** @deprecated should be avoided */
     readonly context: BrowserContext;
+    readonly options: BrowserContextControllerOptions;
     readonly [resolveArgumentType]: BrowserContextControllerArgument;
     constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
     [disposeAsync](): Promise<void>;

package/browser/browser-context-controller.js

@@ -21,9 +21,9 @@ __export(browser_context_controller_exports, {
   BrowserContextController: () => BrowserContextController
 });
 module.exports = __toCommonJS(browser_context_controller_exports);
-var import_decorators = require("../container/decorators.js");
-var import_interfaces = require("../container/interfaces.js");
 var import_disposable = require("../disposable/disposable.js");
+var import_decorators = require("../injector/decorators.js");
+var import_interfaces = require("../injector/interfaces.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_controller = require("./browser-controller.js");
@@ -43,10 +43,11 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-let BrowserContextController = class BrowserContextController2 {
-  options;
+var BrowserContextController_1;
+let BrowserContextController = BrowserContextController_1 = class BrowserContextController2 {
   /** @deprecated should be avoided */
   context;
+  options;
   constructor(context, options = {}) {
     this.context = context;
     this.options = options;
@@ -94,12 +95,17 @@ let BrowserContextController = class BrowserContextController2 {
     (0, import_utils.attachLogger)(this.context, logger);
   }
 };
-BrowserContextController = __decorate([
-  (0, import_decorators.injectable)({
+BrowserContextController = BrowserContextController_1 = __decorate([
+  (0, import_decorators.Injectable)({
     provider: {
-      useFactory: async (argument, context) => {
-        const browserController = await context.resolveAsync(import_browser_controller.BrowserController);
-        return browserController.newContext(argument);
+      useFactory: (_, context) => {
+        context.context.browserController = context.resolve(import_browser_controller.BrowserController);
+        return new BrowserContextController_1(null);
+      },
+      async afterResolve(value, argument, context) {
+        const { context: browserContext, controllerOptions } = await context.browserController.newRawContext(argument);
+        value.context = browserContext;
+        value.options = controllerOptions;
       }
     }
   }),

package/browser/browser-controller.d.ts

@@ -1,10 +1,10 @@
-import type { Browser } from 'playwright';
-import type { Injectable } from '../container/interfaces.js';
-import { resolveArgumentType } from '../container/interfaces.js';
+import type { Browser, BrowserContext } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
+import type { Resolvable } from '../injector/interfaces.js';
+import { resolveArgumentType } from '../injector/interfaces.js';
 import type { Record } from '../types.js';
-import type { BrowserContextState, NewPageOptions } from './browser-context-controller.js';
+import type { BrowserContextControllerOptions, BrowserContextState, NewPageOptions } from './browser-context-controller.js';
 import { BrowserContextController } from './browser-context-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
 export type BrowserControllerOptions = {
@@ -29,13 +29,20 @@ export type NewBrowserContextOptions = {
     };
 };
 export type BrowserControllerArgument = NewBrowserOptions;
-export declare class BrowserController implements AsyncDisposable, Injectable<BrowserControllerArgument> {
+export declare class BrowserController implements AsyncDisposable, Resolvable<BrowserControllerArgument> {
     /** @deprecated should be avoided */
     readonly browser: Browser;
     readonly options: BrowserControllerOptions | undefined;
     readonly [resolveArgumentType]: BrowserControllerArgument;
     constructor(browser: Browser, options?: BrowserControllerOptions);
     [disposeAsync](): Promise<void>;
+    /**
+     * @deprecated for internal use
+     */
+    newRawContext(options?: NewBrowserContextOptions): Promise<{
+        context: BrowserContext;
+        controllerOptions: BrowserContextControllerOptions;
+    }>;
     newContext(options?: NewBrowserContextOptions): Promise<BrowserContextController>;
     close(): Promise<void>;
     waitForNoContexts(): Promise<void>;

package/browser/browser-controller.js

@@ -21,9 +21,10 @@ __export(browser_controller_exports, {
   BrowserController: () => BrowserController
 });
 module.exports = __toCommonJS(browser_controller_exports);
-var import_decorators = require("../container/decorators.js");
-var import_interfaces = require("../container/interfaces.js");
 var import_disposable = require("../disposable/disposable.js");
+var import_decorators = require("../injector/decorators.js");
+var import_inject = require("../injector/inject.js");
+var import_interfaces = require("../injector/interfaces.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_context_controller = require("./browser-context-controller.js");
@@ -43,7 +44,8 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-let BrowserController = class BrowserController2 {
+var BrowserController_1;
+let BrowserController = BrowserController_1 = class BrowserController2 {
   /** @deprecated should be avoided */
   browser;
   options;
@@ -54,7 +56,10 @@ let BrowserController = class BrowserController2 {
   async [import_disposable.disposeAsync]() {
     await this.close();
   }
-  async newContext(options) {
+  /**
+   * @deprecated for internal use
+   */
+  async newRawContext(options) {
     const mergedOptions = (0, import_utils.mergeNewBrowserContextOptions)(this.options?.defaultNewContextOptions, options);
     const context = await this.browser.newContext({
       storageState: mergedOptions.state,
@@ -65,7 +70,11 @@ let BrowserController = class BrowserController2 {
       proxy: mergedOptions.proxy,
       extraHTTPHeaders: (0, import_type_guards.isDefined)(mergedOptions.extraHttpHeaders) ? (0, import_object.filterUndefinedFromRecord)(mergedOptions.extraHttpHeaders) : void 0
     });
-    return new import_browser_context_controller.BrowserContextController(context, mergedOptions);
+    return { context, controllerOptions: mergedOptions };
+  }
+  async newContext(options) {
+    const { context, controllerOptions } = await this.newRawContext(options);
+    return new import_browser_context_controller.BrowserContextController(context, controllerOptions);
   }
   async close() {
     if (this.browser.isConnected()) {
@@ -94,12 +103,17 @@ let BrowserController = class BrowserController2 {
     });
   }
 };
-BrowserController = __decorate([
-  (0, import_decorators.injectable)({
+BrowserController = BrowserController_1 = __decorate([
+  (0, import_decorators.Injectable)({
     provider: {
-      useFactory: async (argument, context) => {
-        const browserService = await context.resolveAsync(import_browser_service.BrowserService);
-        return browserService.newBrowser(argument);
+      useFactory: (_argument, context) => {
+        context.context.browserService = (0, import_inject.inject)(import_browser_service.BrowserService);
+        return new BrowserController_1(null);
+      },
+      async afterResolve(value, argument, context) {
+        const { browser, controllerOptions } = await context.browserService.newRawBrowser(argument);
+        value.browser = browser;
+        value.options = controllerOptions;
       }
     }
   }),

package/browser/browser.service.d.ts

@@ -1,10 +1,10 @@
-import type { LaunchOptions } from 'playwright';
-import type { Injectable } from '../container/interfaces.js';
-import { afterResolve, resolveArgumentType } from '../container/interfaces.js';
+import type { Browser, LaunchOptions } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
+import type { Resolvable } from '../injector/interfaces.js';
+import { resolveArgumentType } from '../injector/interfaces.js';
 import { BrowserContextController } from './browser-context-controller.js';
-import type { NewBrowserContextOptions } from './browser-controller.js';
+import type { BrowserControllerOptions, NewBrowserContextOptions } from './browser-controller.js';
 import { BrowserController } from './browser-controller.js';
 export declare class BrowserServiceOptions {
     defaultNewBrowserOptions?: NewBrowserOptions;
@@ -22,14 +22,20 @@ export type NewBrowserOptions = {
     browserArguments?: string[];
     defaultNewContextOptions?: NewBrowserContextOptions;
 };
-export declare class BrowserService implements AsyncDisposable, Injectable<BrowserServiceArgument> {
+export declare class BrowserService implements AsyncDisposable, Resolvable<BrowserServiceArgument> {
     private readonly browsers;
     private readonly persistentBrowserContexts;
     readonly options: BrowserServiceOptions | undefined;
     readonly [resolveArgumentType]: BrowserServiceArgument;
     constructor(options?: BrowserServiceOptions);
-    [afterResolve](): void;
     [disposeAsync](): Promise<void>;
+    /**
+     * @deprecated internal use only
+     */
+    newRawBrowser(options?: NewBrowserOptions): Promise<{
+        browser: Browser;
+        controllerOptions: BrowserControllerOptions;
+    }>;
     newBrowser(options?: NewBrowserOptions): Promise<BrowserController>;
     newPersistentContext(dataDirectory: string, browserOptions?: NewBrowserOptions, contextOptions?: NewBrowserContextOptions): Promise<BrowserContextController>;
     waitForNoBrowsers(): Promise<void>;

package/browser/browser.service.js

@@ -22,10 +22,9 @@ __export(browser_service_exports, {
   BrowserServiceOptions: () => BrowserServiceOptions
 });
 module.exports = __toCommonJS(browser_service_exports);
-var import_decorators = require("../container/decorators.js");
-var import_interfaces = require("../container/interfaces.js");
-var import_core = require("../core.js");
 var import_disposable = require("../disposable/disposable.js");
+var import_decorators = require("../injector/decorators.js");
+var import_interfaces = require("../injector/interfaces.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_context_controller = require("./browser-context-controller.js");
@@ -63,19 +62,23 @@ let BrowserService = class BrowserService2 {
     this.browsers = /* @__PURE__ */ new Set();
     this.persistentBrowserContexts = /* @__PURE__ */ new Set();
   }
-  [import_interfaces.afterResolve]() {
-    import_core.disposer.add(this);
-  }
   async [import_disposable.disposeAsync]() {
     return this.dispose();
   }
-  async newBrowser(options) {
+  /**
+   * @deprecated internal use only
+   */
+  async newRawBrowser(options) {
     const mergedOptions = { ...this.options?.defaultNewBrowserOptions, ...options };
     const launchOptions = (0, import_utils.getLaunchOptions)(mergedOptions);
     const browser = await (0, import_module.getBrowserType)(mergedOptions.browser).launch(launchOptions);
     this.browsers.add(browser);
     browser.once("disconnected", () => this.browsers.delete(browser));
-    return new import_browser_controller.BrowserController(browser, { defaultNewContextOptions: mergedOptions.defaultNewContextOptions });
+    return { browser, controllerOptions: { defaultNewContextOptions: mergedOptions.defaultNewContextOptions } };
+  }
+  async newBrowser(options) {
+    const { browser, controllerOptions } = await this.newRawBrowser(options);
+    return new import_browser_controller.BrowserController(browser, controllerOptions);
   }
   async newPersistentContext(dataDirectory, browserOptions = {}, contextOptions = {}) {
     const mergedBrowserOptions = { ...this.options?.defaultNewBrowserOptions, ...browserOptions };
@@ -118,7 +121,7 @@ let BrowserService = class BrowserService2 {
   }
 };
 BrowserService = __decorate([
-  (0, import_decorators.singleton)(),
-  __param(0, (0, import_decorators.injectArg)()),
+  (0, import_decorators.Singleton)(),
+  __param(0, (0, import_decorators.InjectArg)()),
   __metadata("design:paramtypes", [BrowserServiceOptions])
 ], BrowserService);

package/browser/module.js

@@ -23,8 +23,8 @@ __export(module_exports, {
 });
 module.exports = __toCommonJS(module_exports);
 var import_playwright = require("playwright");
-var import_container = require("../container/container.js");
 var import_not_supported_error = require("../error/not-supported.error.js");
+var import_injector = require("../injector/injector.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_browser_service = require("./browser.service.js");
@@ -39,7 +39,7 @@ function configureBrowser(options) {
     (0, import_object.copyObjectProperties)(filtered, browserTypes);
   }
   if ((0, import_type_guards.isDefined)(options.options)) {
-    import_container.container.register(import_browser_service.BrowserServiceOptions, { useValue: options.options });
+    import_injector.Injector.register(import_browser_service.BrowserServiceOptions, { useValue: options.options });
   }
 }
 function getBrowserType(type) {

package/container/decorators.d.ts

@@ -1,76 +1,2 @@
-import type { Decorator } from '../reflection/index.js';
-import type { Constructor, OneOrMany, Simplify, TypedOmit } from '../types.js';
-import type { RegistrationOptions } from './container.js';
-import type { Provider } from './provider.js';
-import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
-type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
-export type InjectableOptions<T, A> = RegistrationOptions<T> & {
-    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
-    alias?: OneOrMany<InjectionToken>;
-    /** custom provider. Useful for example if initialization is required */
-    provider?: Provider<T, A>;
-};
-export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
-/**
- * Helper decorator to replace a class definition with an other
- * can be used for example to type external classes with the {@link Injectable} interface
- * @param constructor class to replace with
- */
-export declare function replaceClass<T>(constructor: Constructor<T>): ClassDecorator;
-/**
- * registers the class in the global container. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function injectable<T = any, A = any>(options?: InjectableOptions<T, A>): ClassDecorator;
-/**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function scoped<T = any, A = any>(lifecycle: 'resolution', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * sets the token used to resolve the parameter
- * @param token token used for resolving
- * @param argument resolve argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export declare function inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * sets the argument used for resolving the parameter
- * @param argument
- */
-export declare function resolveArg<T>(argument: T): InjectDecorator;
-/**
- * sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export declare function resolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
-/**
- * injects the argument used for resolving the class instead of resolving the parameter
- * @param argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export declare function injectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
- * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
- */
-export declare function forwardArg(): InjectDecorator;
-export declare function forwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
-/**
- * marks the argument as optional
- * @param argument
- */
-export declare function optional(): InjectDecorator;
-/**
- * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
- * @param argument resolve argument
- */
-export declare function forwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;
-export {};
+export { ForwardArg as forwardArg, ForwardRef as forwardRef, Inject as inject, InjectArg as injectArg, Injectable as injectable, Optional as optional, ReplaceClass as replaceClass, ResolveArg as resolveArg, ResolveArgProvider as resolveArgProvider, Scoped as scoped, Singleton as singleton } from '../injector/decorators.js';
+export type { InjectableOptionsWithoutLifecycle } from '../injector/decorators.js';

package/container/decorators.js

@@ -18,93 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var decorators_exports = {};
 __export(decorators_exports, {
-  forwardArg: () => forwardArg,
-  forwardRef: () => forwardRef,
-  inject: () => inject,
-  injectArg: () => injectArg,
-  injectable: () => injectable,
-  optional: () => optional,
-  replaceClass: () => replaceClass,
-  resolveArg: () => resolveArg,
-  resolveArgProvider: () => resolveArgProvider,
-  scoped: () => scoped,
-  singleton: () => singleton
+  forwardArg: () => import_decorators.ForwardArg,
+  forwardRef: () => import_decorators.ForwardRef,
+  inject: () => import_decorators.Inject,
+  injectArg: () => import_decorators.InjectArg,
+  injectable: () => import_decorators.Injectable,
+  optional: () => import_decorators.Optional,
+  replaceClass: () => import_decorators.ReplaceClass,
+  resolveArg: () => import_decorators.ResolveArg,
+  resolveArgProvider: () => import_decorators.ResolveArgProvider,
+  scoped: () => import_decorators.Scoped,
+  singleton: () => import_decorators.Singleton
 });
 module.exports = __toCommonJS(decorators_exports);
-var import_reflection = require("../reflection/index.js");
-var import_array = require("../utils/array/array.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_container = require("./container.js");
-function replaceClass(constructor) {
-  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
-}
-function injectable(options = {}) {
-  return (0, import_reflection.createClassDecorator)({
-    data: { [import_container.injectMetadataSymbol]: {} },
-    mergeData: true,
-    handler: (data) => {
-      const { alias: aliases, provider, ...registrationOptions } = options;
-      const targetProvider = provider ?? { useClass: data.constructor };
-      import_container.container.register(data.constructor, targetProvider, registrationOptions);
-      if ((0, import_type_guards.isDefined)(aliases)) {
-        for (const alias of (0, import_array.toArray)(aliases)) {
-          import_container.container.register(alias, { useToken: data.constructor }, registrationOptions);
-        }
-      }
-    }
-  });
-}
-function singleton(options = {}) {
-  return injectable({ ...options, lifecycle: "singleton" });
-}
-function scoped(lifecycle, options = {}) {
-  return injectable({ ...options, lifecycle });
-}
-function inject(token, argument, mapperOrKey) {
-  const injectMetadata = {};
-  if ((0, import_type_guards.isDefined)(token)) {
-    injectMetadata.injectToken = token;
-  }
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
-    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
-  }
-  return createInjectDecorator(injectMetadata);
-}
-function resolveArg(argument) {
-  return resolveArgProvider(() => argument);
-}
-function resolveArgProvider(argumentProvider) {
-  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
-}
-function injectArg(mapperOrKey) {
-  return createInjectDecorator({
-    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
-  });
-}
-function forwardArg(mapper = (value) => value) {
-  return createInjectDecorator({ forwardArgumentMapper: mapper });
-}
-function optional() {
-  return createInjectDecorator({ optional: true });
-}
-function forwardRef(token, argument) {
-  const injectMetadata = {
-    forwardRefToken: token
-  };
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  return createInjectDecorator(injectMetadata);
-}
-function createInjectDecorator(metadata) {
-  return (0, import_reflection.createDecorator)({
-    property: true,
-    accessor: true,
-    constructorParameter: true,
-    data: { [import_container.injectMetadataSymbol]: metadata },
-    mergeData: true
-  });
-}
+var import_decorators = require("../injector/decorators.js");

package/container/index.d.ts

@@ -1,10 +1,3 @@
-export * from './container.js';
 export * from './decorators.js';
 export * from './interfaces.js';
-export * from './provider.js';
-export * from './resolve-chain.js';
-export * from './resolve.error.js';
 export * from './token.js';
-export * from './type-info.js';
-export * from './types.js';
-export * from './utils.js';

package/container/index.js

@@ -15,13 +15,6 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var container_exports = {};
 module.exports = __toCommonJS(container_exports);
-__reExport(container_exports, require("./container.js"), module.exports);
 __reExport(container_exports, require("./decorators.js"), module.exports);
 __reExport(container_exports, require("./interfaces.js"), module.exports);
-__reExport(container_exports, require("./provider.js"), module.exports);
-__reExport(container_exports, require("./resolve-chain.js"), module.exports);
-__reExport(container_exports, require("./resolve.error.js"), module.exports);
 __reExport(container_exports, require("./token.js"), module.exports);
-__reExport(container_exports, require("./type-info.js"), module.exports);
-__reExport(container_exports, require("./types.js"), module.exports);
-__reExport(container_exports, require("./utils.js"), module.exports);

package/container/interfaces.d.ts

@@ -1,16 +1,2 @@
-export declare const resolveArgumentType: unique symbol;
-export declare const afterResolve: unique symbol;
-export type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
-export interface Injectable<T = unknown> {
-    /**
-     * type of resolve argument
-     * @deprecated only used for type inference
-     */
-    readonly [resolveArgumentType]: T;
-}
-export interface AfterResolve {
-    /**
-     * called after resolve through container
-     */
-    [afterResolve](): void | Promise<void>;
-}
+export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
+export type { AfterResolve, Resolvable as Injectable, ResolveArgument as InjectableArgument } from '../injector/interfaces.js';

package/container/interfaces.js

@@ -18,9 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var interfaces_exports = {};
 __export(interfaces_exports, {
-  afterResolve: () => afterResolve,
-  resolveArgumentType: () => resolveArgumentType
+  afterResolve: () => import_interfaces.afterResolve,
+  resolveArgumentType: () => import_interfaces.resolveArgumentType
 });
 module.exports = __toCommonJS(interfaces_exports);
-const resolveArgumentType = Symbol("resolveArgumentType");
-const afterResolve = Symbol("after resolve");
+var import_interfaces = require("../injector/interfaces.js");

package/container/token.d.ts

@@ -1,18 +1,2 @@
-import type { AbstractConstructor, EnumerationObject } from '../types.js';
-declare const type: unique symbol;
-declare const argument: unique symbol;
-export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
-    [argument]?: A;
-};
-export type SimpleInjectionToken<T> = AbstractConstructor<T> | EnumerationObject;
-export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
-export declare class ReifyingInjectionToken<T = any, A = any> {
-    private readonly [type];
-    private readonly [argument];
-    readonly description: string;
-    constructor(description: string);
-    toString(): string;
-}
-export declare function injectionToken<T, A = any>(description: string): InjectionToken<T, A>;
-export declare function getTokenName(token: InjectionToken | undefined): string;
-export {};
+export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';
+export type { ArgumentedInjectionToken, InjectionToken, SimpleInjectionToken } from '../injector/token.js';

package/container/token.js

@@ -18,24 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var token_exports = {};
 __export(token_exports, {
-  ReifyingInjectionToken: () => ReifyingInjectionToken,
-  getTokenName: () => getTokenName,
-  injectionToken: () => injectionToken
+  ReifyingInjectionToken: () => import_token.ReifyingInjectionToken,
+  getTokenName: () => import_token.getTokenName,
+  injectionToken: () => import_token.injectionToken
 });
 module.exports = __toCommonJS(token_exports);
-var import_type_guards = require("../utils/type-guards.js");
-class ReifyingInjectionToken {
-  description;
-  constructor(description) {
-    this.description = description;
-  }
-  toString() {
-    return `InjectionToken["${this.description}"]`;
-  }
-}
-function injectionToken(description) {
-  return new ReifyingInjectionToken(description);
-}
-function getTokenName(token) {
-  return (0, import_type_guards.isFunction)(token) ? token.name : (0, import_type_guards.isString)(token) ? `"${token}"` : String(token);
-}
+var import_token = require("../injector/token.js");