{"version":3,"file":"injectable.decorator-DbpiDrg-.cjs","names":["simpleHash","str","hash","i","length","char","charCodeAt","Math","abs","toString","generateTokenId","name","customId","base","split","InjectionToken","id","formattedName","schema","create","bound","token","value","BoundInjectionToken","factory","FactoryInjectionToken","refineType","className","resolved","resolve","ctx","Registry","factories","Map","highestPriority","parent","has","token","id","get","factory","Error","toString","getAll","records","length","sort","a","b","priority","set","scope","target","type","record","originalToken","existing","push","currentHighest","delete","deletedHighest","remaining","filter","r","newHighest","reduce","max","current","updateScope","forEach","highest","globalRegistry","InjectableScope","InjectableType","InjectableTokenMeta","InjectionToken","globalRegistry","Injectable","scope","Singleton","token","schema","registry","priority","target","context","kind","Function","Error","injectableToken","create","set","Class"],"sources":["../src/enums/injectable-scope.enum.mts","../src/enums/injectable-type.enum.mts","../src/symbols/injectable-token.mts","../src/token/injection-token.mts","../src/token/registry.mts","../src/decorators/injectable.decorator.mts"],"sourcesContent":["export enum InjectableScope {\n  /**\n   * Singleton scope: The instance is created once and shared across the application.\n   */\n  Singleton = 'Singleton',\n  /**\n   * Instance scope: A new instance is created for each injection.\n   */\n  Transient = 'Transient',\n  /**\n   * Request scope: The instance is created once per request and shared within that request context.\n   */\n  Request = 'Request',\n}\n\n","export enum InjectableType {\n  Class = 'Class',\n  Factory = 'Factory',\n}\n\n","export const InjectableTokenMeta = /* #__PURE__ */ Symbol.for(\n  'InjectableTokenMeta',\n)\n","import type { z, ZodObject, ZodOptional, ZodRecord } from 'zod/v4'\n\nimport type { FactoryContext } from '../internal/context/factory-context.mjs'\n\nexport type ClassType = new (...args: any[]) => any\nexport type ClassTypeWithoutArguments = new () => any\nexport type ClassTypeWithArgument<Arg> = new (arg: Arg) => any\nexport type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any\n\nexport type ClassTypeWithInstance<T> = new (...args: any[]) => T\nexport type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T\nexport type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (\n  arg?: Arg,\n) => T\n\nexport type BaseInjectionTokenSchemaType = ZodObject | ZodRecord\n\nexport type OptionalInjectionTokenSchemaType =\n  | ZodOptional<ZodObject>\n  | ZodOptional<ZodRecord>\n\nexport type InjectionTokenSchemaType =\n  | BaseInjectionTokenSchemaType\n  | OptionalInjectionTokenSchemaType\n\n/**\n * Simple hash function for deterministic ID generation\n */\nfunction simpleHash(str: string): string {\n  let hash = 0\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n  return Math.abs(hash).toString(36)\n}\n\n/**\n * Generate deterministic ID from token name\n */\nfunction generateTokenId(name: string | symbol | ClassType, customId?: string): string {\n  if (customId) {\n    return customId\n  }\n\n  let base: string\n  if (typeof name === 'function') {\n    base = `${name.name}_${name.toString()}`\n  } else if (typeof name === 'symbol') {\n    base = `symbol_${name.toString()}`\n  } else {\n    base = `token_${name}`\n  }\n\n  return `${base.split('_')[0]}_${simpleHash(base)}`\n}\n\nexport class InjectionToken<\n  // oxlint-disable-next-line no-unused-vars\n  T,\n  S extends InjectionTokenSchemaType | unknown = unknown,\n  // oxlint-disable-next-line no-unused-vars\n  Required extends boolean = S extends ZodOptional<ZodObject>\n    ? false\n    : S extends ZodOptional<ZodRecord>\n      ? false\n      : S extends ZodObject\n        ? true\n        : S extends ZodRecord\n          ? true\n          : false,\n> {\n  public readonly id: string\n  private formattedName: string | null = null\n\n  constructor(\n    public readonly name: string | symbol | ClassType,\n    public readonly schema: ZodObject | undefined,\n    customId?: string,\n  ) {\n    this.id = generateTokenId(name, customId)\n  }\n\n  static create<T extends ClassType>(\n    name: T,\n  ): InjectionToken<InstanceType<T>, undefined>\n  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(\n    name: T,\n    schema: Schema,\n  ): Schema['_def']['type'] extends 'ZodOptional'\n    ? InjectionToken<InstanceType<T>, Schema, false>\n    : InjectionToken<InstanceType<T>, Schema, true>\n  static create<T>(name: string | symbol): InjectionToken<T, undefined>\n  static create<T, Schema extends InjectionTokenSchemaType>(\n    name: string | any,\n    schema: Schema,\n  ): InjectionToken<T, Schema>\n  static create(name: string | symbol, schema?: unknown, customId?: string) {\n    // @ts-expect-error\n    return new InjectionToken(name, schema, customId)\n  }\n\n  static bound<T, S extends InjectionTokenSchemaType>(\n    token: InjectionToken<T, S>,\n    value: z.input<S>,\n  ): BoundInjectionToken<T, S> {\n    return new BoundInjectionToken(token, value)\n  }\n\n  static factory<T, S extends InjectionTokenSchemaType>(\n    token: InjectionToken<T, S>,\n    factory: (ctx: FactoryContext) => Promise<z.input<S>>,\n  ): FactoryInjectionToken<T, S> {\n    return new FactoryInjectionToken(token, factory)\n  }\n\n  static refineType<T>(\n    token: BoundInjectionToken<any, any>,\n  ): BoundInjectionToken<T, any> {\n    return token as BoundInjectionToken<T, any>\n  }\n\n  toString() {\n    if (this.formattedName) {\n      return this.formattedName\n    }\n    const { name } = this\n    if (typeof name === 'function') {\n      const className = name.name\n      this.formattedName = `${className}(${this.id})`\n    } else if (typeof name === 'symbol') {\n      this.formattedName = `${name.toString()}(${this.id})`\n    } else {\n      this.formattedName = `${name}(${this.id})`\n    }\n\n    return this.formattedName\n  }\n}\n\nexport class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {\n  public id: string\n  public name: string | symbol | ClassType\n  public schema: InjectionTokenSchemaType\n\n  constructor(\n    public readonly token: InjectionToken<T, S>,\n    public readonly value: z.input<S>,\n  ) {\n    this.name = token.name\n    this.id = token.id\n    this.schema = token.schema as InjectionTokenSchemaType\n  }\n\n  toString() {\n    return this.token.toString()\n  }\n}\n\nexport class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {\n  public value?: z.input<S>\n  public resolved = false\n  public id: string\n  public name: string | symbol | ClassType\n  public schema: InjectionTokenSchemaType\n\n  constructor(\n    public readonly token: InjectionToken<T, S>,\n    public readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>,\n  ) {\n    this.name = token.name\n    this.id = token.id\n    this.schema = token.schema as InjectionTokenSchemaType\n  }\n\n  async resolve(ctx: FactoryContext): Promise<z.input<S>> {\n    if (!this.value) {\n      this.value = await this.factory(ctx)\n      this.resolved = true\n    }\n    return this.value\n  }\n\n  toString() {\n    return this.token.toString()\n  }\n}\n\nexport type AnyInjectableType =\n  | ClassType\n  | InjectionToken<any, any>\n  | BoundInjectionToken<any, any>\n  | FactoryInjectionToken<any, any>\n\nexport type InjectionTokenType =\n  | InjectionToken<any, any>\n  | BoundInjectionToken<any, any>\n  | FactoryInjectionToken<any, any>\n\n","import type { ClassType, InjectionToken } from './injection-token.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\n\nexport type FactoryRecord<Instance = any, Schema = any> = {\n  scope: InjectableScope\n  originalToken: InjectionToken<Instance, Schema>\n  target: ClassType\n  type: InjectableType\n  priority: number\n}\n\nexport class Registry {\n  private readonly factories = new Map<string, FactoryRecord[]>()\n  private readonly highestPriority = new Map<string, FactoryRecord>()\n\n  constructor(private readonly parent?: Registry) {}\n\n  has(token: InjectionToken<any, any>): boolean {\n    if (this.factories.has(token.id)) {\n      return true\n    }\n    if (this.parent) {\n      return this.parent.has(token)\n    }\n    return false\n  }\n\n  get<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n  ): FactoryRecord<Instance, Schema> {\n    const factory = this.highestPriority.get(token.id)\n    if (!factory) {\n      if (this.parent) {\n        return this.parent.get(token)\n      }\n      throw new Error(`[Registry] No factory found for ${token.toString()}`)\n    }\n    return factory\n  }\n\n  getAll<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n  ): FactoryRecord<Instance, Schema>[] {\n    const records = this.factories.get(token.id)\n    if (!records || records.length === 0) {\n      if (this.parent) {\n        return this.parent.getAll(token)\n      }\n      return []\n    }\n    // Return sorted by priority (highest first)\n    return [...records].sort((a, b) => b.priority - a.priority)\n  }\n\n  set<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n    scope: InjectableScope,\n    target: ClassType,\n    type: InjectableType,\n    priority: number = 0,\n  ) {\n    const record: FactoryRecord<Instance, Schema> = {\n      scope,\n      originalToken: token,\n      target,\n      type,\n      priority,\n    }\n\n    // Add to factories array\n    const existing = this.factories.get(token.id) || []\n    existing.push(record)\n    this.factories.set(token.id, existing)\n\n    // Update highest priority cache if needed\n    const currentHighest = this.highestPriority.get(token.id)\n    if (!currentHighest || priority > currentHighest.priority) {\n      this.highestPriority.set(token.id, record)\n    }\n  }\n\n  delete(token: InjectionToken<any, any>) {\n    const records = this.factories.get(token.id)\n    if (records) {\n      const deletedHighest = this.highestPriority.get(token.id)\n      this.factories.delete(token.id)\n      this.highestPriority.delete(token.id)\n\n      // If we deleted the highest priority record, recalculate from remaining records\n      if (deletedHighest && records.length > 1) {\n        const remaining = records.filter(\n          (r) =>\n            r.originalToken.id !== deletedHighest.originalToken.id ||\n            r.priority !== deletedHighest.priority,\n        )\n        if (remaining.length > 0) {\n          const newHighest = remaining.reduce((max, current) =>\n            current.priority > max.priority ? current : max,\n          )\n          this.highestPriority.set(token.id, newHighest)\n          this.factories.set(token.id, remaining)\n        }\n      }\n    }\n  }\n\n  /**\n   * Updates the scope of an already registered factory.\n   * This is useful when you need to dynamically change a service's scope\n   * (e.g., when a singleton controller has request-scoped dependencies).\n   *\n   * @param token The injection token to update\n   * @param scope The new scope to set\n   * @returns true if the scope was updated, false if the token was not found\n   */\n  updateScope(\n    token: InjectionToken<any, any>,\n    scope: InjectableScope,\n  ): boolean {\n    const records = this.factories.get(token.id)\n    if (records && records.length > 0) {\n      // Update all records\n      records.forEach((record) => {\n        record.scope = scope\n      })\n      // Update highest priority cache if it exists\n      const highest = this.highestPriority.get(token.id)\n      if (highest) {\n        highest.scope = scope\n      }\n      return true\n    }\n    if (this.parent) {\n      return this.parent.updateScope(token, scope)\n    }\n    return false\n  }\n}\n\nexport const globalRegistry = /* #__PURE__ */ new Registry()\n","import type { z } from 'zod/v4'\n\nimport type {\n  BaseInjectionTokenSchemaType,\n  ClassType,\n  ClassTypeWithArgument,\n  ClassTypeWithInstance,\n  ClassTypeWithInstanceAndArgument,\n  ClassTypeWithInstanceAndOptionalArgument,\n  ClassTypeWithOptionalArgument,\n  ClassTypeWithoutArguments,\n  InjectionTokenSchemaType,\n  OptionalInjectionTokenSchemaType,\n} from '../token/injection-token.mjs'\nimport type { Registry } from '../token/registry.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\nimport { InjectableTokenMeta } from '../symbols/index.mjs'\nimport { InjectionToken } from '../token/injection-token.mjs'\nimport { globalRegistry } from '../token/registry.mjs'\n\nexport interface InjectableOptions {\n  scope?: InjectableScope\n  token?: InjectionToken<any, any>\n  schema?: InjectionTokenSchemaType\n  registry?: Registry\n  priority?: number\n}\n\n// #1 Simple constructorless class\nexport function Injectable(): <T extends ClassTypeWithoutArguments>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\nexport function Injectable(options: {\n  scope?: InjectableScope\n  registry: Registry\n  priority?: number\n}): <T extends ClassTypeWithoutArguments>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\nexport function Injectable(options: {\n  scope: InjectableScope\n  priority?: number\n}): <T extends ClassTypeWithoutArguments>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n// #2 Class with schema\nexport function Injectable<Schema extends InjectionTokenSchemaType>(options: {\n  scope?: InjectableScope\n  schema: Schema\n  registry?: Registry\n  priority?: number\n}): <T extends ClassTypeWithArgument<z.output<Schema>>>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\n// #3 Class with typeless token and schema\nexport function Injectable<Type, Schema>(options: {\n  scope?: InjectableScope\n  token: InjectionToken<Type, Schema>\n  registry?: Registry\n  priority?: number\n}): Schema extends BaseInjectionTokenSchemaType\n  ? Type extends undefined\n    ? <T extends ClassTypeWithArgument<z.output<Schema>>>(\n        target: T,\n        context?: ClassDecoratorContext,\n      ) => T\n    : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>(\n        target: T,\n        context?: ClassDecoratorContext,\n      ) => T\n  : Schema extends OptionalInjectionTokenSchemaType\n    ? Type extends undefined\n      ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(\n          target: T,\n          context?: ClassDecoratorContext,\n        ) => T\n      : <\n          T extends ClassTypeWithInstanceAndOptionalArgument<\n            Type,\n            z.output<Schema>\n          >,\n        >(\n          target: T,\n          context?: ClassDecoratorContext,\n        ) => T\n    : Schema extends undefined\n      ? <R extends ClassTypeWithInstance<Type>>(\n          target: R,\n          context?: ClassDecoratorContext,\n        ) => R\n      : never\n\nexport function Injectable({\n  scope = InjectableScope.Singleton,\n  token,\n  schema,\n  registry = globalRegistry,\n  priority = 0,\n}: InjectableOptions = {}) {\n  return <T extends ClassType>(\n    target: T,\n    context?: ClassDecoratorContext,\n  ): T => {\n    if (\n      (context && context.kind !== 'class') ||\n      (target instanceof Function && !context)\n    ) {\n      throw new Error('[DI] @Injectable decorator can only be used on classes.')\n    }\n    if (schema && token) {\n      throw new Error(\n        '[DI] @Injectable decorator cannot have both a token and a schema',\n      )\n    }\n    let injectableToken: InjectionToken<any, any> =\n      token ?? InjectionToken.create(target, schema as InjectionTokenSchemaType)\n\n    registry.set(injectableToken, scope, target, InjectableType.Class, priority)\n\n    // @ts-expect-error\n    target[InjectableTokenMeta] = injectableToken\n\n    return target\n  }\n}\n"],"mappings":"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"}