@navios/di 0.1.3 → 0.1.5

package/dist/_tsup-dts-rollup.d.mts

@@ -1,9 +1,4 @@
-import { AnyZodObject } from 'zod';
-import { BoundInjectionToken as BoundInjectionToken_2 } from './injection-token.mjs';
-import { ClassType as ClassType_2 } from './injection-token.mjs';
-import { FactoryInjectionToken as FactoryInjectionToken_2 } from './injection-token.mjs';
-import { InjectionToken as InjectionToken_2 } from './injection-token.mjs';
-import { input } from 'zod';
+import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
 
@@ -29,10 +24,18 @@ declare type ClassType = new (...args: any[]) => any;
 export { ClassType }
 export { ClassType as ClassType_alias_1 }
 
+declare type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+export { ClassTypeWithArgument }
+export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
+
 declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
 export { ClassTypeWithInstance }
 export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
 
+declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+export { ClassTypeWithInstanceAndArgument }
+export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -173,14 +176,7 @@ declare const globalRegistry: Registry;
 export { globalRegistry }
 export { globalRegistry as globalRegistry_alias_1 }
 
-declare const inject: {
-    <T extends ClassType_2>(token: T): Promise<InstanceType<T>>;
-    <T, S extends AnyZodObject>(token: InjectionToken_2<T, S>, args: input<S>): Promise<T>;
-    <T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken_2<T, S>, args?: input<S>): Promise<T>;
-    <T>(token: InjectionToken_2<T, undefined>): Promise<T>;
-    <T>(token: BoundInjectionToken_2<T, any>): Promise<T>;
-    <T>(token: FactoryInjectionToken_2<T, any>): Promise<T>;
-};
+declare const inject: Injectors['inject'];
 export { inject }
 export { inject as inject_alias_1 }
 
@@ -188,13 +184,6 @@ declare function Injectable(): <T extends ClassType>(target: T, context: ClassDe
     [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
 };
 
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
 declare function Injectable<R>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
@@ -202,6 +191,29 @@ declare function Injectable<R>(options: {
     [InjectableTokenMeta]: InjectionToken<R, undefined>;
 };
 
+declare function Injectable<S extends AnyZodObject>(options: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<undefined, S>;
+}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<T, S>;
+};
+
+declare function Injectable<R, S extends AnyZodObject>(options: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<R, S>;
+}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<R, S>;
+};
+
+declare function Injectable<T extends ClassType>(options: {
+    scope?: InjectableScope;
+    token: InjectionToken<T, undefined>;
+}): (target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
+};
+
 declare function Injectable<R, S extends AnyZodObject>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
@@ -336,7 +348,7 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 export { makeProxyServiceLocator }
 export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
 
-declare const provideServiceLocator: (locator: ServiceLocator) => ServiceLocator;
+declare const provideServiceLocator: Injectors['provideServiceLocator'];
 export { provideServiceLocator }
 export { provideServiceLocator as provideServiceLocator_alias_1 }
 
@@ -509,14 +521,7 @@ declare class ServiceLocatorManager {
 export { ServiceLocatorManager }
 export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
 
-declare const syncInject: {
-    <T extends ClassType_2>(token: T): InstanceType<T>;
-    <T, S extends AnyZodObject>(token: InjectionToken_2<T, S>, args: input<S>): T;
-    <T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken_2<T, S>, args?: input<S>): T;
-    <T>(token: InjectionToken_2<T, undefined>): T;
-    <T>(token: BoundInjectionToken_2<T, any>): T;
-    <T>(token: FactoryInjectionToken_2<T, any>): T;
-};
+declare const syncInject: Injectors['syncInject'];
 export { syncInject }
 export { syncInject as syncInject_alias_1 }
 
@@ -529,7 +534,7 @@ export { UnknownError }
 export { UnknownError as UnknownError_alias_1 }
 export { UnknownError as UnknownError_alias_2 }
 
-declare const wrapSyncInit: (cb: () => any) => () => [any, Promise<any>[]];
+declare const wrapSyncInit: Injectors['wrapSyncInit'];
 export { wrapSyncInit }
 export { wrapSyncInit as wrapSyncInit_alias_1 }
 

package/dist/_tsup-dts-rollup.d.ts

@@ -1,9 +1,4 @@
-import { AnyZodObject } from 'zod';
-import { BoundInjectionToken as BoundInjectionToken_2 } from './injection-token.mjs';
-import { ClassType as ClassType_2 } from './injection-token.mjs';
-import { FactoryInjectionToken as FactoryInjectionToken_2 } from './injection-token.mjs';
-import { InjectionToken as InjectionToken_2 } from './injection-token.mjs';
-import { input } from 'zod';
+import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
 
@@ -29,10 +24,18 @@ declare type ClassType = new (...args: any[]) => any;
 export { ClassType }
 export { ClassType as ClassType_alias_1 }
 
+declare type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+export { ClassTypeWithArgument }
+export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
+
 declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
 export { ClassTypeWithInstance }
 export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
 
+declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+export { ClassTypeWithInstanceAndArgument }
+export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -173,14 +176,7 @@ declare const globalRegistry: Registry;
 export { globalRegistry }
 export { globalRegistry as globalRegistry_alias_1 }
 
-declare const inject: {
-    <T extends ClassType_2>(token: T): Promise<InstanceType<T>>;
-    <T, S extends AnyZodObject>(token: InjectionToken_2<T, S>, args: input<S>): Promise<T>;
-    <T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken_2<T, S>, args?: input<S>): Promise<T>;
-    <T>(token: InjectionToken_2<T, undefined>): Promise<T>;
-    <T>(token: BoundInjectionToken_2<T, any>): Promise<T>;
-    <T>(token: FactoryInjectionToken_2<T, any>): Promise<T>;
-};
+declare const inject: Injectors['inject'];
 export { inject }
 export { inject as inject_alias_1 }
 
@@ -188,13 +184,6 @@ declare function Injectable(): <T extends ClassType>(target: T, context: ClassDe
     [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
 };
 
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
 declare function Injectable<R>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
@@ -202,6 +191,29 @@ declare function Injectable<R>(options: {
     [InjectableTokenMeta]: InjectionToken<R, undefined>;
 };
 
+declare function Injectable<S extends AnyZodObject>(options: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<undefined, S>;
+}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<T, S>;
+};
+
+declare function Injectable<R, S extends AnyZodObject>(options: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<R, S>;
+}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<R, S>;
+};
+
+declare function Injectable<T extends ClassType>(options: {
+    scope?: InjectableScope;
+    token: InjectionToken<T, undefined>;
+}): (target: T, context: ClassDecoratorContext) => T & {
+    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
+};
+
 declare function Injectable<R, S extends AnyZodObject>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
@@ -336,7 +348,7 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 export { makeProxyServiceLocator }
 export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
 
-declare const provideServiceLocator: (locator: ServiceLocator) => ServiceLocator;
+declare const provideServiceLocator: Injectors['provideServiceLocator'];
 export { provideServiceLocator }
 export { provideServiceLocator as provideServiceLocator_alias_1 }
 
@@ -509,14 +521,7 @@ declare class ServiceLocatorManager {
 export { ServiceLocatorManager }
 export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
 
-declare const syncInject: {
-    <T extends ClassType_2>(token: T): InstanceType<T>;
-    <T, S extends AnyZodObject>(token: InjectionToken_2<T, S>, args: input<S>): T;
-    <T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken_2<T, S>, args?: input<S>): T;
-    <T>(token: InjectionToken_2<T, undefined>): T;
-    <T>(token: BoundInjectionToken_2<T, any>): T;
-    <T>(token: FactoryInjectionToken_2<T, any>): T;
-};
+declare const syncInject: Injectors['syncInject'];
 export { syncInject }
 export { syncInject as syncInject_alias_1 }
 
@@ -529,7 +534,7 @@ export { UnknownError }
 export { UnknownError as UnknownError_alias_1 }
 export { UnknownError as UnknownError_alias_2 }
 
-declare const wrapSyncInit: (cb: () => any) => () => [any, Promise<any>[]];
+declare const wrapSyncInit: Injectors['wrapSyncInit'];
 export { wrapSyncInit }
 export { wrapSyncInit as wrapSyncInit_alias_1 }
 

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 export { Injectable } from './_tsup-dts-rollup.mjs';
 export { InjectableOptions } from './_tsup-dts-rollup.mjs';
-export { InjectableTokenMeta } from './_tsup-dts-rollup.mjs';
 export { InjectableScope } from './_tsup-dts-rollup.mjs';
 export { InjectableType } from './_tsup-dts-rollup.mjs';
 export { ErrorsEnum } from './_tsup-dts-rollup.mjs';
@@ -25,7 +24,9 @@ export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-
 export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.mjs';
 export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.mjs';
 export { ClassType } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithArgument } from './_tsup-dts-rollup.mjs';
 export { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.mjs';
 export { InjectionToken } from './_tsup-dts-rollup.mjs';
 export { BoundInjectionToken } from './_tsup-dts-rollup.mjs';
 export { FactoryInjectionToken } from './_tsup-dts-rollup.mjs';
@@ -52,3 +53,4 @@ export { ServiceLocatorInstanceHolderCreated } from './_tsup-dts-rollup.mjs';
 export { ServiceLocatorInstanceHolderDestroying } from './_tsup-dts-rollup.mjs';
 export { ServiceLocatorInstanceHolder } from './_tsup-dts-rollup.mjs';
 export { ServiceLocatorManager } from './_tsup-dts-rollup.mjs';
+export { InjectableTokenMeta } from './_tsup-dts-rollup.mjs';

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export { Injectable } from './_tsup-dts-rollup.js';
 export { InjectableOptions } from './_tsup-dts-rollup.js';
-export { InjectableTokenMeta } from './_tsup-dts-rollup.js';
 export { InjectableScope } from './_tsup-dts-rollup.js';
 export { InjectableType } from './_tsup-dts-rollup.js';
 export { ErrorsEnum } from './_tsup-dts-rollup.js';
@@ -25,7 +24,9 @@ export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-
 export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.js';
 export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.js';
 export { ClassType } from './_tsup-dts-rollup.js';
+export { ClassTypeWithArgument } from './_tsup-dts-rollup.js';
 export { ClassTypeWithInstance } from './_tsup-dts-rollup.js';
+export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.js';
 export { InjectionToken } from './_tsup-dts-rollup.js';
 export { BoundInjectionToken } from './_tsup-dts-rollup.js';
 export { FactoryInjectionToken } from './_tsup-dts-rollup.js';
@@ -52,3 +53,4 @@ export { ServiceLocatorInstanceHolderCreated } from './_tsup-dts-rollup.js';
 export { ServiceLocatorInstanceHolderDestroying } from './_tsup-dts-rollup.js';
 export { ServiceLocatorInstanceHolder } from './_tsup-dts-rollup.js';
 export { ServiceLocatorManager } from './_tsup-dts-rollup.js';
+export { InjectableTokenMeta } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -58,6 +58,7 @@ module.exports = __toCommonJS(src_exports);
 
 // packages/di/src/decorators/injectable.decorator.mts
 var import_common2 = require("@navios/common");
+var import_zod3 = require("zod");
 
 // packages/di/src/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
@@ -229,6 +230,9 @@ function makeProxyServiceLocator(serviceLocator, ctx) {
   return new ProxyServiceLocator(serviceLocator, ctx);
 }
 
+// packages/di/src/symbols/injectable-token.mts
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
 // packages/di/src/utils/get-injectors.mts
 var InjectorsBase = /* @__PURE__ */ new Map();
 function getInjectors({ baseLocator }) {
@@ -333,7 +337,6 @@ async function resolveService(ctx, target, args = []) {
 }
 
 // packages/di/src/decorators/injectable.decorator.mts
-var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 function Injectable({
   scope = "Singleton" /* Singleton */,
   type = "Class" /* Class */,
@@ -350,7 +353,7 @@ function Injectable({
     if (type === "Class" /* Class */) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args) => resolveService(ctx, target, [args]),
         scope
       );
     } else if (type === "Factory" /* Factory */) {
@@ -443,7 +446,7 @@ var UnknownError = class extends Error {
 };
 
 // packages/di/src/interfaces/factory.interface.mts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // packages/di/src/event-emitter.mts
 var EventEmitter = class {
@@ -978,9 +981,13 @@ function getGlobalServiceLocator() {
   }
   return globalServiceLocator;
 }
-var { inject, syncInject, wrapSyncInit, provideServiceLocator } = getInjectors({
+var values = getInjectors({
   baseLocator: globalServiceLocator
 });
+var inject = values.inject;
+var syncInject = values.syncInject;
+var wrapSyncInit = values.wrapSyncInit;
+var provideServiceLocator = values.provideServiceLocator;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BoundInjectionToken,

package/dist/index.mjs

@@ -1,5 +1,6 @@
 // packages/di/src/decorators/injectable.decorator.mts
 import { NaviosException as NaviosException2 } from "@navios/common";
+import "zod";
 
 // packages/di/src/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
@@ -171,6 +172,9 @@ function makeProxyServiceLocator(serviceLocator, ctx) {
   return new ProxyServiceLocator(serviceLocator, ctx);
 }
 
+// packages/di/src/symbols/injectable-token.mts
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
 // packages/di/src/utils/get-injectors.mts
 var InjectorsBase = /* @__PURE__ */ new Map();
 function getInjectors({ baseLocator }) {
@@ -275,7 +279,6 @@ async function resolveService(ctx, target, args = []) {
 }
 
 // packages/di/src/decorators/injectable.decorator.mts
-var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 function Injectable({
   scope = "Singleton" /* Singleton */,
   type = "Class" /* Class */,
@@ -292,7 +295,7 @@ function Injectable({
     if (type === "Class" /* Class */) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args) => resolveService(ctx, target, [args]),
         scope
       );
     } else if (type === "Factory" /* Factory */) {
@@ -920,9 +923,13 @@ function getGlobalServiceLocator() {
   }
   return globalServiceLocator;
 }
-var { inject, syncInject, wrapSyncInit, provideServiceLocator } = getInjectors({
+var values = getInjectors({
   baseLocator: globalServiceLocator
 });
+var inject = values.inject;
+var syncInject = values.syncInject;
+var wrapSyncInit = values.wrapSyncInit;
+var provideServiceLocator = values.provideServiceLocator;
 export {
   BoundInjectionToken,
   ErrorsEnum,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/__tests__/injectable.spec.mts

@@ -79,7 +79,7 @@ describe('Injectable decorator', () => {
     expect(value).toBeInstanceOf(Test)
   })
 
-  it('should work with injection token and schema', async () => {
+  it('should work with factory injection token and schema', async () => {
     class TestFoo {
       constructor(public readonly foo: string) {}
     }
@@ -164,4 +164,22 @@ describe('Injectable decorator', () => {
     const result2 = await inst2.makeFoo()
     expect(result1).toBe(result2)
   })
+
+  it('should work with constructor argument', async () => {
+    const schema = z.object({
+      foo: z.string(),
+    })
+
+    const token = InjectionToken.create('Test', schema)
+
+    @Injectable({ token })
+    class Test {
+      constructor(public readonly arg: z.output<typeof schema>) {}
+    }
+
+    const value = await inject(token, { foo: 'bar' })
+    expect(value).toBeInstanceOf(Test)
+    // @ts-expect-error It's a test
+    expect(value.arg).toEqual({ foo: 'bar' })
+  })
 })

package/src/decorators/injectable.decorator.mts

@@ -2,7 +2,14 @@ import type { AnyZodObject } from 'zod'
 
 import { NaviosException } from '@navios/common'
 
-import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
+import { z } from 'zod'
+
+import type {
+  ClassType,
+  ClassTypeWithArgument,
+  ClassTypeWithInstance,
+  ClassTypeWithInstanceAndArgument,
+} from '../injection-token.mjs'
 import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
 import type { Registry } from '../registry.mjs'
 
@@ -10,6 +17,7 @@ import { InjectableScope, InjectableType } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
 import { globalRegistry } from '../registry.mjs'
 import { resolveService } from '../resolve-service.mjs'
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export interface InjectableOptions {
   scope?: InjectableScope
@@ -18,12 +26,33 @@ export interface InjectableOptions {
   registry?: Registry
 }
 
-export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')
-
 export function Injectable(): <T extends ClassType>(
   target: T,
   context: ClassDecoratorContext,
 ) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
+export function Injectable<R>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+}): <T extends ClassTypeWithInstance<Factory<R>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+export function Injectable<S extends AnyZodObject>(options: {
+  scope?: InjectableScope
+  type?: InjectableType.Class
+  token: InjectionToken<undefined, S>
+}): <T extends ClassTypeWithArgument<z.output<S>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<T, S> }
+export function Injectable<R, S extends AnyZodObject>(options: {
+  scope?: InjectableScope
+  type?: InjectableType.Class
+  token: InjectionToken<R, S>
+}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, S> }
 export function Injectable<T extends ClassType>(options: {
   scope?: InjectableScope
   token: InjectionToken<T, undefined>
@@ -33,13 +62,7 @@ export function Injectable<T extends ClassType>(options: {
 ) => T & {
   [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
 }
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+
 export function Injectable<R, S extends AnyZodObject>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
@@ -78,7 +101,7 @@ export function Injectable({
     if (type === InjectableType.Class) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args: any) => resolveService(ctx, target, [args]),
         scope,
       )
     } else if (type === InjectableType.Factory) {

package/src/index.mts

@@ -14,3 +14,4 @@ export * from './service-locator.mjs'
 export * from './service-locator-event-bus.mjs'
 export * from './service-locator-instance-holder.mjs'
 export * from './service-locator-manager.mjs'
+export * from './symbols/injectable-token.mjs'

package/src/injection-token.mts

@@ -5,8 +5,10 @@ import { randomUUID } from 'crypto'
 import { z, ZodOptional } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
+export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
 
 export type ClassTypeWithInstance<T> = new (...args: any[]) => T
+export type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T
 
 export class InjectionToken<
   T,

package/src/injector.mts

@@ -1,3 +1,5 @@
+import type { Injectors } from './utils/index.mjs'
+
 import { ServiceLocator } from './service-locator.mjs'
 import { getInjectors } from './utils/index.mjs'
 
@@ -11,9 +13,15 @@ export function getGlobalServiceLocator(): ServiceLocator {
   }
   return globalServiceLocator
 }
-const { inject, syncInject, wrapSyncInit, provideServiceLocator } =
-  getInjectors({
-    baseLocator: globalServiceLocator,
-  })
+const values = getInjectors({
+  baseLocator: globalServiceLocator,
+})
+
+export const inject: Injectors['inject'] = values.inject
+
+export const syncInject: Injectors['syncInject'] = values.syncInject
+
+export const wrapSyncInit: Injectors['wrapSyncInit'] = values.wrapSyncInit
 
-export { inject, syncInject, wrapSyncInit, provideServiceLocator }
+export const provideServiceLocator: Injectors['provideServiceLocator'] =
+  values.provideServiceLocator

package/src/symbols/index.mts

@@ -0,0 +1 @@
+export * from './injectable-token.mjs'

package/src/symbols/injectable-token.mts

@@ -0,0 +1 @@
+export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')

package/src/utils/get-injectable-token.mts

@@ -1,6 +1,6 @@
 import type { ClassType, InjectionToken } from '../injection-token.mjs'
 
-import { InjectableTokenMeta } from '../decorators/index.mjs'
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export function getInjectableToken<R>(
   target: ClassType,

package/src/utils/get-injectors.mts

@@ -1,14 +1,14 @@
 import type { AnyZodObject, z, ZodOptional } from 'zod'
 
-import type { ClassType } from '../injection-token.mjs'
-import type { ServiceLocator } from '../service-locator.mjs'
-
-import { InjectableTokenMeta } from '../decorators/index.mjs'
-import {
+import type {
   BoundInjectionToken,
+  ClassType,
   FactoryInjectionToken,
   InjectionToken,
 } from '../injection-token.mjs'
+import type { ServiceLocator } from '../service-locator.mjs'
+
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export interface CreateInjectorsOptions {
   baseLocator: ServiceLocator