injeca 0.2.0 → 0.4.0

package/dist/testing.mjs

@@ -0,0 +1,103 @@
+import { G as nodeOf, St as InvalidArgumentError, r as validateDecision, t as createDecide } from "./decision-BXZu3N1O.mjs";
+// src/testing/drained.ts
+/**
+* Resolves when the work queue of `container` has drained and stays drained.
+*
+* A build or a hook that settles on a microtask can queue more work after a drain.
+* So it waits one macrotask after each drain, and starts again when another drain happens.
+* The macrotask is a real `setTimeout(0)`, so it does not resolve while the fake timers of a test runner hold `setTimeout`.
+* A `manualClock` does not change `setTimeout`, so the two work together.
+*
+* It does not wait for work that a timer starts later, for example a requeue delay or a policy timeout. Move the clock first, then await `drained` again.
+*/
+function drained(container) {
+	const { reconciler } = nodeOf(container).runtime;
+	return new Promise((resolve) => {
+		let timer;
+		const stopListening = reconciler.onDrained(() => {
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				stopListening();
+				resolve();
+			}, 0);
+		});
+		reconciler.requestDrain();
+	});
+}
+// src/testing/manual-clock.ts
+/**
+* Creates a manual clock for tests. It drives `timeout()`, `withTimeout()`, requeue delays, and the `start` and `stop` policy timeouts without real time.
+*
+* `advance` runs the timer callbacks synchronously. Await `drained(container)` after it, so that the work that the callbacks start settles.
+*/
+function manualClock() {
+	let now = 0;
+	let seq = 0;
+	const timers = /* @__PURE__ */ new Map();
+	return {
+		clock: {
+			now: () => now,
+			setTimeout: (callback, ms) => {
+				const id = ++seq;
+				timers.set(id, {
+					at: now + ms,
+					callback
+				});
+				return () => timers.delete(id);
+			}
+		},
+		advance: (ms) => {
+			now += ms;
+			const due = [...timers].filter(([, timer]) => timer.at <= now).sort(([, a], [, b]) => a.at - b.at);
+			for (const [id, timer] of due) {
+				timers.delete(id);
+				timer.callback();
+			}
+		},
+		pending: () => timers.size
+	};
+}
+// src/testing/testing.ts
+const runs = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.
+*
+* Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.
+*/
+function createHookContext(hook, options = {}) {
+	const attempt = options.attempt ?? 1;
+	if (!Number.isInteger(attempt) || attempt < 1) throw new InvalidArgumentError(`The attempt of a hook context must be an integer of 1 or more. Got ${String(attempt)}.`);
+	const run = {
+		service: options.service ?? "test",
+		instanceId: options.instanceId ?? "test-instance",
+		hook,
+		attempt,
+		now: options.now ?? (() => Date.now())
+	};
+	const dependencyHook = hook === "dependency-change" || hook === "dependency-status-change";
+	const context = Object.freeze({
+		decide: createDecide(run),
+		attempt,
+		previous: options.previous,
+		signal: options.signal ?? new AbortController().signal,
+		...dependencyHook ? {
+			dependsOn: Object.freeze({ ...options.dependsOn }),
+			changes: Object.freeze([...options.changes ?? []])
+		} : {}
+	});
+	runs.set(context, run);
+	return context;
+}
+/**
+* Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.
+*
+* @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.
+*/
+function checkDecision(context, value) {
+	const run = runs.get(context);
+	if (!run) throw new InvalidArgumentError("The context does not come from createHookContext.");
+	return validateDecision(run, value);
+}
+export { checkDecision, createHookContext, drained, manualClock };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../src/testing/drained.ts","../src/testing/manual-clock.ts","../src/testing/testing.ts"],"sourcesContent":["import type { Container } from '../types'\n\nimport { nodeOf } from '../graph/nodes'\n\n/**\n * Resolves when the work queue of `container` has drained and stays drained.\n *\n * A build or a hook that settles on a microtask can queue more work after a drain.\n * So it waits one macrotask after each drain, and starts again when another drain happens.\n * The macrotask is a real `setTimeout(0)`, so it does not resolve while the fake timers of a test runner hold `setTimeout`.\n * A `manualClock` does not change `setTimeout`, so the two work together.\n *\n * It does not wait for work that a timer starts later, for example a requeue delay or a policy timeout. Move the clock first, then await `drained` again.\n */\nexport function drained(container: Container): Promise<void> {\n  const { reconciler } = nodeOf(container).runtime\n\n  return new Promise((resolve) => {\n    let timer: ReturnType<typeof setTimeout> | undefined\n    const stopListening = reconciler.onDrained(() => {\n      clearTimeout(timer)\n      timer = setTimeout(() => {\n        stopListening()\n        resolve()\n      }, 0)\n    })\n    reconciler.requestDrain()\n  })\n}\n","import type { Clock } from '../helpers/clock'\n\n/** A clock that moves only when a test calls `advance`. Pass `clock` to `createContainer`. */\nexport interface ManualClock {\n  /** The clock for `createContainer({ clock })`. Its time starts at 0. */\n  readonly clock: Clock\n  /**\n   * Moves the time forward by `ms`, and runs each timer that is due, in the order of its time.\n   * A timer that a callback sets during the call runs at a later call, also when it is due now.\n   */\n  readonly advance: (ms: number) => void\n  /** The number of timers that wait. A timer that was cancelled or that ran does not count. */\n  readonly pending: () => number\n}\n\n/**\n * Creates a manual clock for tests. It drives `timeout()`, `withTimeout()`, requeue delays, and the `start` and `stop` policy timeouts without real time.\n *\n * `advance` runs the timer callbacks synchronously. Await `drained(container)` after it, so that the work that the callbacks start settles.\n */\nexport function manualClock(): ManualClock {\n  let now = 0\n  let seq = 0\n  const timers = new Map<number, { readonly at: number, readonly callback: () => void }>()\n\n  return {\n    clock: {\n      now: () => now,\n      setTimeout: (callback, ms) => {\n        const id = ++seq\n        timers.set(id, { at: now + ms, callback })\n        return () => timers.delete(id)\n      },\n    },\n    advance: (ms) => {\n      now += ms\n      const due = [...timers].filter(([, timer]) => timer.at <= now).sort(([, a], [, b]) => a.at - b.at)\n      for (const [id, timer] of due) {\n        timers.delete(id)\n        timer.callback()\n      }\n    },\n    pending: () => timers.size,\n  }\n}\n","import type { Decision, HookRun, ServiceHook } from '../primitives/decision'\nimport type { DependencyChange, HookContextFor, HookDependencies } from '../types'\n\nimport { InvalidArgumentError } from '../diagnostics/errors'\nimport { createDecide, validateDecision } from '../primitives/decision'\n\nexport { drained } from './drained'\nexport { manualClock } from './manual-clock'\nexport type { ManualClock } from './manual-clock'\n\nexport interface HookContextOptions<D = undefined> {\n  /** The service name that the decisions carry. It defaults to `'test'`. */\n  service?: string\n  /** The instance id that the decisions carry. It defaults to `'test-instance'`. */\n  instanceId?: string\n  /** It defaults to `1`. */\n  attempt?: number\n  previous?: Decision\n  /** It defaults to a signal that does not abort. */\n  signal?: AbortSignal\n  /** The snapshot of a dependency hook. It defaults to an empty record. */\n  dependsOn?: HookDependencies<D>\n  /** The changes of a dependency hook. It defaults to an empty list. */\n  changes?: readonly DependencyChange[]\n  /** The clock for `issuedAt`. It defaults to `Date.now`. */\n  now?: () => number\n}\n\nconst runs = new WeakMap<object, HookRun>()\n\n/**\n * Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.\n *\n * Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.\n */\nexport function createHookContext<H extends ServiceHook, D = undefined>(hook: H, options: HookContextOptions<D> = {}): HookContextFor<H, D> {\n  const attempt = options.attempt ?? 1\n  if (!Number.isInteger(attempt) || attempt < 1)\n    throw new InvalidArgumentError(`The attempt of a hook context must be an integer of 1 or more. Got ${String(attempt)}.`)\n\n  const run: HookRun = {\n    service: options.service ?? 'test',\n    instanceId: options.instanceId ?? 'test-instance',\n    hook,\n    attempt,\n    now: options.now ?? (() => Date.now()),\n  }\n  const dependencyHook = hook === 'dependency-change' || hook === 'dependency-status-change'\n  const context = Object.freeze({\n    decide: createDecide(run),\n    attempt,\n    previous: options.previous,\n    signal: options.signal ?? new AbortController().signal,\n    ...(dependencyHook ? { dependsOn: Object.freeze({ ...options.dependsOn }), changes: Object.freeze([...(options.changes ?? [])]) } : {}),\n  })\n  runs.set(context, run)\n\n  return context as unknown as HookContextFor<H, D>\n}\n\n/**\n * Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.\n *\n * @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.\n */\nexport function checkDecision(context: object, value: unknown): Decision | undefined {\n  const run = runs.get(context)\n  if (!run)\n    throw new InvalidArgumentError('The context does not come from createHookContext.')\n\n  return validateDecision(run, value)\n}\n"],"mappings":";;;;;;;;;;;;AAcA,SAAgB,QAAQ,WAAqC;CAC3D,MAAM,EAAE,eAAe,OAAO,SAAS,CAAC,CAAC;CAEzC,OAAO,IAAI,SAAS,YAAY;EAC9B,IAAI;EACJ,MAAM,gBAAgB,WAAW,gBAAgB;GAC/C,aAAa,KAAK;GAClB,QAAQ,iBAAiB;IACvB,cAAc;IACd,QAAQ;GACV,GAAG,CAAC;EACN,CAAC;EACD,WAAW,aAAa;CAC1B,CAAC;AACH;;;;;;;ACRA,SAAgB,cAA2B;CACzC,IAAI,MAAM;CACV,IAAI,MAAM;CACV,MAAM,yBAAS,IAAI,IAAoE;CAEvF,OAAO;EACL,OAAO;GACL,WAAW;GACX,aAAa,UAAU,OAAO;IAC5B,MAAM,KAAK,EAAE;IACb,OAAO,IAAI,IAAI;KAAE,IAAI,MAAM;KAAI;IAAS,CAAC;IACzC,aAAa,OAAO,OAAO,EAAE;GAC/B;EACF;EACA,UAAU,OAAO;GACf,OAAO;GACP,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,QAAQ,GAAG,WAAW,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,IAAI,GAAG,OAAO,EAAE,KAAK,EAAE,EAAE;GACjG,KAAK,MAAM,CAAC,IAAI,UAAU,KAAK;IAC7B,OAAO,OAAO,EAAE;IAChB,MAAM,SAAS;GACjB;EACF;EACA,eAAe,OAAO;CACxB;AACF;;AChBA,MAAM,uBAAO,IAAI,QAAyB;;;;;;AAO1C,SAAgB,kBAAwD,MAAS,UAAiC,CAAC,GAAyB;CAC1I,MAAM,UAAU,QAAQ,WAAW;CACnC,IAAI,CAAC,OAAO,UAAU,OAAO,KAAK,UAAU,GAC1C,MAAM,IAAI,qBAAqB,sEAAsE,OAAO,OAAO,EAAE,EAAE;CAEzH,MAAM,MAAe;EACnB,SAAS,QAAQ,WAAW;EAC5B,YAAY,QAAQ,cAAc;EAClC;EACA;EACA,KAAK,QAAQ,cAAc,KAAK,IAAI;CACtC;CACA,MAAM,iBAAiB,SAAS,uBAAuB,SAAS;CAChE,MAAM,UAAU,OAAO,OAAO;EAC5B,QAAQ,aAAa,GAAG;EACxB;EACA,UAAU,QAAQ;EAClB,QAAQ,QAAQ,UAAU,IAAI,gBAAgB,CAAC,CAAC;EAChD,GAAI,iBAAiB;GAAE,WAAW,OAAO,OAAO,EAAE,GAAG,QAAQ,UAAU,CAAC;GAAG,SAAS,OAAO,OAAO,CAAC,GAAI,QAAQ,WAAW,CAAC,CAAE,CAAC;EAAE,IAAI,CAAC;CACvI,CAAC;CACD,KAAK,IAAI,SAAS,GAAG;CAErB,OAAO;AACT;;;;;;AAOA,SAAgB,cAAc,SAAiB,OAAsC;CACnF,MAAM,MAAM,KAAK,IAAI,OAAO;CAC5B,IAAI,CAAC,KACH,MAAM,IAAI,qBAAqB,mDAAmD;CAEpF,OAAO,iBAAiB,KAAK,KAAK;AACpC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "injeca",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Pure functional programming based dependency injection library inspired by go.uber.org/fig and go.uber.org/dig.",
   "author": {
     "name": "Moeru AI Project AIRI Team",
@@ -12,22 +12,28 @@
   "homepage": "https://github.com/moeru-ai/injeca",
   "repository": {
     "type": "git",
-    "url": "https://github.com/moeru-ai/injeca.git"
+    "url": "https://github.com/moeru-ai/injeca.git",
+    "directory": "packages/injeca"
   },
   "exports": {
     ".": {
-      "type": "./dist/index.d.mts",
+      "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
     "./global": {
-      "type": "./dist/global.d.mts",
+      "types": "./dist/global.d.mts",
       "default": "./dist/global.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
     }
   },
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.mts",
+  "types": "./dist/index.d.mts",
   "files": [
+    "LICENSE",
     "README.md",
     "dist",
     "package.json"
@@ -42,31 +48,12 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@antfu/eslint-config": "^8.2.0",
-    "@moeru/eslint-config": "^0.1.0-beta.18",
-    "@moeru/std": "^0.1.0-beta.18",
-    "@moeru/tsconfig": "^0.1.0-beta.18",
-    "@types/node": "^25.6.0",
-    "bumpp": "^11.0.1",
-    "eslint": "^10.2.0",
-    "eslint-plugin-oxlint": "^1.60.0",
-    "oxlint": "^1.60.0",
-    "publint": "^0.3.18",
-    "taze": "^19.11.0",
-    "tsdown": "^0.17.4",
-    "typescript": "^6.0.2",
-    "unplugin-unused": "^0.5.7",
-    "vite": "^8.0.8",
-    "vitest": "^4.1.4"
+  "dependencies": {
+    "alien-signals": "^3.2.1",
+    "es-toolkit": "^1.53.1"
   },
   "scripts": {
     "build": "tsdown",
-    "test": "vitest --coverage",
-    "test:run": "vitest run",
-    "lint": "eslint --cache .",
-    "lint:fix": "eslint --cache --fix .",
-    "typecheck": "tsc --noEmit",
-    "up": "taze -w -r -I -f && pnpm prune && pnpm dedupe"
+    "typecheck": "tsc --noEmit -p ../../tsconfig.json"
   }
 }

package/dist/builtin-BPDNf8Z-.mjs

@@ -1,25 +0,0 @@
-//#region src/builtin.ts
-function buildLifecycle() {
-	const onStartHooks = [];
-	const onStopHooks = [];
-	return {
-		appHooks: {
-			onStart(hook) {
-				if (hook) onStartHooks.push(hook);
-			},
-			onStop(hook) {
-				if (hook) onStopHooks.push(hook);
-			}
-		},
-		emitOnStart: async () => {
-			for (const hook of onStartHooks) await hook();
-		},
-		emitOnStop: async () => {
-			for (const hook of onStopHooks) await hook();
-		}
-	};
-}
-
-//#endregion
-export { buildLifecycle };
-//# sourceMappingURL=builtin-BPDNf8Z-.mjs.map

package/dist/builtin-BPDNf8Z-.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-BPDNf8Z-.mjs","names":["onStartHooks: (() => void | Promise<void>)[]","onStopHooks: (() => void | Promise<void>)[]"],"sources":["../src/builtin.ts"],"sourcesContent":["export interface LifecycleAppHooks {\n  onStart: (hook: () => void | Promise<void>) => void\n  onStop: (hook: () => void | Promise<void>) => void\n}\n\nexport interface Lifecycle {\n  appHooks: LifecycleAppHooks\n}\n\nexport interface LifecycleTriggerable extends Lifecycle {\n  emitOnStart: () => Promise<void>\n  emitOnStop: () => Promise<void>\n}\n\nexport function buildLifecycle(): Lifecycle {\n  const onStartHooks: (() => void | Promise<void>)[] = []\n  const onStopHooks: (() => void | Promise<void>)[] = []\n\n  const lifecycle: LifecycleTriggerable = {\n    appHooks: {\n      onStart(hook: () => void | Promise<void>) {\n        if (hook) {\n          onStartHooks.push(hook)\n        }\n      },\n      onStop(hook: () => void | Promise<void>) {\n        if (hook) {\n          onStopHooks.push(hook)\n        }\n      },\n    },\n    emitOnStart: async () => {\n      for (const hook of onStartHooks) {\n        await hook()\n      }\n    },\n    emitOnStop: async () => {\n      for (const hook of onStopHooks) {\n        await hook()\n      }\n    },\n  }\n\n  return lifecycle\n}\n"],"mappings":";AAcA,SAAgB,iBAA4B;CAC1C,MAAMA,eAA+C,EAAE;CACvD,MAAMC,cAA8C,EAAE;AA2BtD,QAzBwC;EACtC,UAAU;GACR,QAAQ,MAAkC;AACxC,QAAI,KACF,cAAa,KAAK,KAAK;;GAG3B,OAAO,MAAkC;AACvC,QAAI,KACF,aAAY,KAAK,KAAK;;GAG3B;EACD,aAAa,YAAY;AACvB,QAAK,MAAM,QAAQ,aACjB,OAAM,MAAM;;EAGhB,YAAY,YAAY;AACtB,QAAK,MAAM,QAAQ,YACjB,OAAM,MAAM;;EAGjB"}

package/dist/global-BLY6_SI_.d.mts

@@ -1,130 +0,0 @@
-import { Logg } from "@guiiai/logg";
-
-//#region src/builtin.d.ts
-interface LifecycleAppHooks {
-  onStart: (hook: () => void | Promise<void>) => void;
-  onStop: (hook: () => void | Promise<void>) => void;
-}
-interface Lifecycle {
-  appHooks: LifecycleAppHooks;
-}
-interface LifecycleTriggerable extends Lifecycle {
-  emitOnStart: () => Promise<void>;
-  emitOnStop: () => Promise<void>;
-}
-//#endregion
-//#region src/logger.d.ts
-interface Logger {
-  provide: (name: string, dependencies: string[]) => void;
-  invoke: (dependencies: string[]) => void;
-  beforeRun: (name: string) => void;
-  run: (name: string, duration: number) => void;
-  hookOnStart: (name: string) => void;
-  hookOnStartComplete: (name: string, duration: number) => void;
-  hookOnStop: (name: string) => void;
-  hookOnStopComplete: (name: string, duration: number) => void;
-  running: () => void;
-}
-interface LoggerOptions {
-  enabled?: boolean;
-  logger?: Logger;
-}
-declare function createDefaultLogger(): Logger;
-declare function createLoggLogger(logg: Logg): Logger;
-declare function createNoopLogger(): Logger;
-//#endregion
-//#region src/scoped.d.ts
-type DependencyMap = Record<string, any>;
-interface Container {
-  providers: Map<string, ProvideOptionObject<any, any>>;
-  instances: Map<string, any>;
-  lifecycleHooks: Map<string, LifecycleTriggerable>;
-  dependencyGraph: Map<string, string[]>;
-  invocations: InvokeOptionObject<any>[];
-  logger: Logger;
-}
-type BuildContext<D extends DependencyMap | undefined = undefined> = {
-  container: Container;
-  name: string;
-} & (D extends undefined ? {
-  dependsOn?: unknown;
-} : {
-  dependsOn: D;
-});
-type ResolveDependencyDeclaration<Deps extends Record<string, string | ProvidedKey<any, any, any>>> = { [K in keyof Deps]: Deps[K] extends ProvidedKey<any, infer T, any> ? T : Deps[K] extends ProvidedBy<infer T> ? T : any };
-type ProvideOptionObject<T, D extends DependencyMap | undefined = undefined> = {
-  build: (context: BuildContext<D>) => T | Promise<T>;
-} & (D extends undefined ? {
-  dependsOn?: Record<string, never>;
-} : {
-  dependsOn: { [K in keyof D]: string };
-});
-type ProvideOptionFunc<T, D extends DependencyMap | undefined = undefined> = (context: BuildContext<D>) => T | Promise<T>;
-type ProvideOption<T, D extends DependencyMap | undefined = undefined> = ProvideOptionObject<T, D> | ProvideOptionFunc<T, D>;
-interface ProvideOptionObjectWithKeys<T, Deps extends Record<string, string | ProvidedKey<any, any, any>>> {
-  build: (context: BuildContext<ResolveDependencyDeclaration<Deps>>) => T | Promise<T>;
-  dependsOn: Deps;
-}
-type ProvideOptionWithKeys<T, Deps extends Record<string, string | ProvidedKey<any, any, any>>> = ProvideOptionObjectWithKeys<T, Deps>;
-type InvokeOptionObject<D extends DependencyMap | undefined = undefined> = {
-  callback: (dependencies: D) => void | Promise<void>;
-} & (D extends undefined ? {
-  dependsOn?: Record<string, never>;
-} : {
-  dependsOn: { [K in keyof D]: string };
-});
-type InvokeOptionFunc<D extends DependencyMap | undefined = undefined> = (dependencies: D) => void | Promise<void>;
-type InvokeOption<D extends DependencyMap | undefined = undefined> = InvokeOptionObject<D> | InvokeOptionFunc<D>;
-interface InvokeOptionObjectWithKeys<Deps extends Record<string, string | ProvidedKey<any, any, any>>> {
-  callback: (dependencies: ResolveDependencyDeclaration<Deps>) => void | Promise<void>;
-  dependsOn: Deps;
-}
-type InvokeOptionWithKeys<Deps extends Record<string, string | ProvidedKey<any, any, any>>> = InvokeOptionObjectWithKeys<Deps>;
-declare const lifecycle: ProvidedKey<'lifecycle', Lifecycle, undefined>;
-declare function createContainer(options?: LoggerOptions): Container;
-interface ProvidedKey<Key, _T, _D extends DependencyMap | undefined> {
-  key: Key;
-}
-type ProvidedBy<T> = string & {
-  __providedType?: T;
-};
-type InferProvided<T> = T extends ProvidedKey<any, infer P, any> ? P : T extends ProvidedBy<infer P> ? P : never;
-declare function provide$1<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(container: Container, name: Key, option: ProvideOptionWithKeys<T, Deps>): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>;
-declare function provide$1<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(container: Container, option: ProvideOptionWithKeys<T, Deps> & {
-  autoNameStackIndex?: number;
-}): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>;
-declare function provide$1<D extends DependencyMap | undefined, T = any, Key extends string = string>(container: Container, name: Key, option: ProvideOption<T, D>): ProvidedKey<Key, T, D>;
-declare function provide$1<D extends DependencyMap | undefined, T = any, Key extends string = string>(container: Container, option: ProvideOption<T, D> & {
-  autoNameStackIndex?: number;
-}): ProvidedKey<Key, T, D>;
-declare function invoke$1<Deps extends Record<string, string | ProvidedKey<any, any, any>>>(container: Container, option: InvokeOptionWithKeys<Deps>): void;
-declare function invoke$1<D extends DependencyMap>(container: Container, option: InvokeOption<D>): void;
-declare function resolve$1<Deps extends Record<string, string | ProvidedKey<any, any, any>>>(container: Container, dependsOn: Deps): Promise<ResolveDependencyDeclaration<Deps>>;
-declare function start$1(container: Container): Promise<void>;
-declare function stop$1(container: Container): Promise<void>;
-//#endregion
-//#region src/index.d.ts
-declare const injeca: {
-  provide: typeof provide;
-  invoke: typeof invoke;
-  resolve: typeof resolve;
-  start: typeof start;
-  stop: typeof stop;
-  setLogger: typeof setLogger;
-};
-//#endregion
-//#region src/global.d.ts
-declare function setLogger(logger: Logger): void;
-declare function resetContainer(): void;
-declare function provide<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(name: Key, option: ProvideOptionWithKeys<T, Deps>): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>;
-declare function provide<D extends DependencyMap | undefined, T = any, Key extends string = string>(name: Key, option: ProvideOption<T, D>): ProvidedKey<Key, T, D>;
-declare function provide<T, Key extends string, Deps extends Record<string, string | ProvidedKey<any, any, any>>>(option: ProvideOptionWithKeys<T, Deps>): ProvidedKey<Key, T, ResolveDependencyDeclaration<Deps>>;
-declare function provide<D extends DependencyMap | undefined, T = any, Key extends string = string>(option: ProvideOption<T, D>): ProvidedKey<Key, T, D>;
-declare function invoke<Deps extends Record<string, string | ProvidedKey<any, any, any>>>(option: InvokeOptionWithKeys<Deps>): void;
-declare function invoke<D extends DependencyMap>(option: InvokeOption<D>): void;
-declare function resolve<Deps extends Record<string, string | ProvidedKey<any, any, any>>>(dependsOn: Deps): Promise<ResolveDependencyDeclaration<Deps>>;
-declare function start(): Promise<void>;
-declare function stop(): Promise<void>;
-//#endregion
-export { resolve$1 as A, ProvidedBy as C, invoke$1 as D, createContainer as E, createDefaultLogger as F, createLoggLogger as I, createNoopLogger as L, stop$1 as M, Logger as N, lifecycle as O, LoggerOptions as P, Lifecycle as R, ProvideOptionWithKeys as S, ResolveDependencyDeclaration as T, InvokeOptionWithKeys as _, setLogger as a, ProvideOptionObject as b, injeca as c, DependencyMap as d, InferProvided as f, InvokeOptionObjectWithKeys as g, InvokeOptionObject as h, resolve as i, start$1 as j, provide$1 as k, BuildContext as l, InvokeOptionFunc as m, provide as n, start as o, InvokeOption as p, resetContainer as r, stop as s, invoke as t, Container as u, ProvideOption as v, ProvidedKey as w, ProvideOptionObjectWithKeys as x, ProvideOptionFunc as y };
-//# sourceMappingURL=global-BLY6_SI_.d.mts.map

package/dist/src-UXkTj4Np.mjs

@@ -1,294 +0,0 @@
-import ErrorStackParser from "error-stack-parser";
-import { nanoid } from "nanoid";
-
-//#region src/global.ts
-let globalContainer = createContainer();
-function setLogger(logger) {
-	globalContainer.logger = logger;
-}
-function resetContainer() {
-	globalContainer = createContainer();
-}
-function provide(nameOrOption, option) {
-	if (option != null && typeof option === "function") return provide$1(globalContainer, nameOrOption, {
-		build: option,
-		autoNameStackIndex: 2
-	});
-	return provide$1(globalContainer, nameOrOption, {
-		...option,
-		autoNameStackIndex: 2
-	});
-}
-function invoke(option) {
-	if (typeof option === "function") globalContainer.invocations.push({ callback: option });
-	else globalContainer.invocations.push(option);
-}
-function resolve(dependsOn) {
-	return resolve$1(globalContainer, dependsOn);
-}
-function start() {
-	return start$1(globalContainer);
-}
-function stop() {
-	return stop$1(globalContainer);
-}
-
-//#endregion
-//#region package.json
-var name = "injeca";
-
-//#endregion
-//#region src/logger.ts
-function formatDuration(ms) {
-	if (ms < 1) return `${(ms * 1e3).toFixed(3)}µs`;
-	if (ms < 1e3) return `${ms.toFixed(3)}ms`;
-	return `${(ms / 1e3).toFixed(3)}s`;
-}
-function createDefaultLogger() {
-	return {
-		provide: (name$1, dependencies) => {
-			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
-			console.log(`[${name$1}] PROVIDE    ${name$1}${depsStr}`);
-		},
-		invoke: (dependencies) => {
-			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
-			console.log(`[${name}] INVOKE${depsStr}`);
-		},
-		beforeRun: (name$1) => {
-			console.log(`[${name$1}] BEFORE RUN provide: ${name$1}()`);
-		},
-		run: (name$1, duration) => {
-			console.log(`[${name$1}] RUN        provide: ${name$1}() in ${formatDuration(duration)}`);
-		},
-		hookOnStart: (name$1) => {
-			console.log(`[${name$1}] HOOK OnStart        ${name$1}() executing`);
-		},
-		hookOnStartComplete: (name$1, duration) => {
-			console.log(`[${name$1}] HOOK OnStart        ${name$1}() ran successfully in ${formatDuration(duration)}`);
-		},
-		hookOnStop: (name$1) => {
-			console.log(`[${name$1}] HOOK OnStop         ${name$1}() executing`);
-		},
-		hookOnStopComplete: (name$1, duration) => {
-			console.log(`[${name$1}] HOOK OnStop         ${name$1}() ran successfully in ${formatDuration(duration)}`);
-		},
-		running: () => {
-			console.log(`[${name}] RUNNING`);
-		}
-	};
-}
-function createLoggLogger(logg) {
-	return {
-		provide: (name$1, dependencies) => {
-			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
-			logg.log(`PROVIDE    ${name$1}${depsStr}`);
-		},
-		invoke: (dependencies) => {
-			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
-			logg.log(`INVOKE${depsStr}`);
-		},
-		beforeRun: (name$1) => {
-			logg.log(`BEFORE RUN provide: ${name$1}()`);
-		},
-		run: (name$1, duration) => {
-			logg.log(`RUN        provide: ${name$1}() in ${formatDuration(duration)}`);
-		},
-		hookOnStart: (name$1) => {
-			logg.log(`HOOK OnStart        ${name$1}() executing`);
-		},
-		hookOnStartComplete: (name$1, duration) => {
-			logg.log(`HOOK OnStart        ${name$1}() ran successfully in ${formatDuration(duration)}`);
-		},
-		hookOnStop: (name$1) => {
-			logg.log(`HOOK OnStop         ${name$1}() executing`);
-		},
-		hookOnStopComplete: (name$1, duration) => {
-			logg.log(`HOOK OnStop         ${name$1}() ran successfully in ${formatDuration(duration)}`);
-		},
-		running: () => {
-			logg.log(`RUNNING`);
-		}
-	};
-}
-function createNoopLogger() {
-	return {
-		provide: () => {},
-		invoke: () => {},
-		beforeRun: () => {},
-		run: () => {},
-		hookOnStart: () => {},
-		hookOnStartComplete: () => {},
-		hookOnStop: () => {},
-		hookOnStopComplete: () => {},
-		running: () => {}
-	};
-}
-
-//#endregion
-//#region src/scoped.ts
-const lifecycle = { key: "lifecycle" };
-function createContainer(options) {
-	const logger = options?.enabled === false ? createNoopLogger() : options?.logger ?? createDefaultLogger();
-	return {
-		providers: /* @__PURE__ */ new Map(),
-		instances: /* @__PURE__ */ new Map(),
-		lifecycleHooks: /* @__PURE__ */ new Map(),
-		dependencyGraph: /* @__PURE__ */ new Map(),
-		invocations: [],
-		logger
-	};
-}
-function normalizeName(nameOrProvidedKey) {
-	if (typeof nameOrProvidedKey === "object" && nameOrProvidedKey !== null && "key" in nameOrProvidedKey) return nameOrProvidedKey.key;
-	return nameOrProvidedKey;
-}
-function normalizeProvideOption(nameOrOption, option) {
-	if (typeof nameOrOption === "string") {
-		if (option == null || !("build" in option) && typeof option !== "function") throw new Error("When using provide(...) as named callback, the second argument must be either a valid ProvideOptionObject<T, D> or a ProvideOptionFunc<T, D>.");
-		if (typeof option === "function") return { build: option };
-		return option;
-	}
-	if (typeof nameOrOption === "object" && "key" in nameOrOption) {
-		if (option == null || !("build" in option) && typeof option !== "function") throw new Error("When using provide(...) as typed ProvideOptionWithKeys<T, D, Key> callback, the second argument must be either a valid ProvideOptionObject<T, D> or a ProvideOptionFunc<T, D>.");
-		if (typeof option === "function") return { build: option };
-		return option;
-	}
-	if (typeof nameOrOption === "function") return { build: nameOrOption };
-	return nameOrOption;
-}
-function provide$1(container, nameOrOption, option) {
-	const parentFile = ErrorStackParser.parse(/* @__PURE__ */ new Error("providing"))[option?.autoNameStackIndex ?? 1];
-	const name$1 = typeof nameOrOption === "string" ? nameOrOption : `${parentFile.fileName ?? `unknown-${nanoid()}`}:${parentFile.lineNumber ?? 0}:${parentFile.columnNumber ?? 0}`;
-	const providerObject = normalizeProvideOption(nameOrOption, option);
-	if (providerObject.dependsOn) {
-		const resolvedDependsOn = {};
-		for (const [key, value] of Object.entries(providerObject.dependsOn)) resolvedDependsOn[key] = normalizeName(value);
-		providerObject.dependsOn = resolvedDependsOn;
-	}
-	container.providers.set(name$1, providerObject);
-	const dependencies = providerObject.dependsOn ? Object.values(providerObject.dependsOn) : [];
-	container.logger.provide(name$1, dependencies);
-	container.dependencyGraph.set(name$1, dependencies);
-	return { key: name$1 };
-}
-function invoke$1(container, option) {
-	const invocationObject = typeof option === "function" ? { callback: option } : option;
-	if (invocationObject.dependsOn) {
-		const resolvedDependsOn = {};
-		for (const [key, value] of Object.entries(invocationObject.dependsOn)) resolvedDependsOn[key] = normalizeName(value);
-		invocationObject.dependsOn = resolvedDependsOn;
-	}
-	const dependencies = invocationObject.dependsOn ? Object.values(invocationObject.dependsOn) : [];
-	container.logger.invoke(dependencies);
-	container.invocations.push(invocationObject);
-}
-async function resolveInstance(container, name$1) {
-	if (container.instances.has(name$1)) {
-		const existing = container.instances.get(name$1);
-		return existing instanceof Promise ? await existing : existing;
-	}
-	const provider = container.providers.get(name$1);
-	if (!provider) throw new Error(`No provider found for '${name$1}'`);
-	const resolvedDependencies = {};
-	let serviceLifecycle = null;
-	if (provider.dependsOn) for (const [key, depName] of Object.entries(provider.dependsOn)) if (depName === "lifecycle") {
-		const { buildLifecycle } = await import("./builtin-BPDNf8Z-.mjs");
-		serviceLifecycle = buildLifecycle();
-		resolvedDependencies[key] = serviceLifecycle;
-		container.lifecycleHooks.set(name$1, serviceLifecycle);
-	} else resolvedDependencies[key] = await resolveInstance(container, depName);
-	const context = {
-		container,
-		dependsOn: resolvedDependencies,
-		name: name$1
-	};
-	async function buildAndStore() {
-		container.logger.beforeRun(name$1);
-		const startTime = performance.now();
-		const instance = await provider.build(context);
-		const duration = performance.now() - startTime;
-		container.logger.run(name$1, duration);
-		container.instances.set(name$1, instance);
-		return instance;
-	}
-	const buildPromise = buildAndStore();
-	container.instances.set(name$1, buildPromise);
-	return await buildPromise;
-}
-async function resolve$1(container, dependsOn) {
-	const resolved = {};
-	for (const [key, depName] of Object.entries(dependsOn)) resolved[key] = await resolveInstance(container, normalizeName(depName));
-	return resolved;
-}
-function topologicalSort(dependencyGraph) {
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const result = [];
-	function visit(node) {
-		if (visiting.has(node)) throw new Error(`Circular dependency detected involving '${node}'`);
-		if (visited.has(node)) return;
-		visiting.add(node);
-		const dependencies = dependencyGraph.get(node) || [];
-		for (const dep of dependencies) visit(dep);
-		visiting.delete(node);
-		visited.add(node);
-		result.push(node);
-	}
-	for (const node of dependencyGraph.keys()) if (!visited.has(node)) visit(node);
-	return result;
-}
-async function startLifecycleHooks(container) {
-	const sortedServices = topologicalSort(container.dependencyGraph);
-	for (const serviceName of sortedServices) {
-		const lifecycle$1 = container.lifecycleHooks.get(serviceName);
-		if (lifecycle$1?.emitOnStart) {
-			container.logger.hookOnStart(serviceName);
-			const startTime = performance.now();
-			await lifecycle$1.emitOnStart();
-			const duration = performance.now() - startTime;
-			container.logger.hookOnStartComplete(serviceName, duration);
-		}
-	}
-}
-async function stopLifecycleHooks(container) {
-	const sortedServices = topologicalSort(container.dependencyGraph);
-	for (const serviceName of sortedServices.reverse()) {
-		const lifecycle$1 = container.lifecycleHooks.get(serviceName);
-		if (lifecycle$1?.emitOnStop) {
-			container.logger.hookOnStop(serviceName);
-			const startTime = performance.now();
-			await lifecycle$1.emitOnStop();
-			const duration = performance.now() - startTime;
-			container.logger.hookOnStopComplete(serviceName, duration);
-		}
-	}
-}
-async function start$1(container) {
-	const resolvedInvocations = [];
-	for (const invocation of container.invocations) {
-		const resolvedDependencies = {};
-		if (invocation.dependsOn) for (const [key, depName] of Object.entries(invocation.dependsOn)) resolvedDependencies[key] = await resolveInstance(container, normalizeName(depName));
-		resolvedInvocations.push(resolvedDependencies);
-	}
-	await startLifecycleHooks(container);
-	for (const [index, invocation] of container.invocations.entries()) await invocation.callback(resolvedInvocations[index] ?? {});
-	container.logger.running();
-}
-async function stop$1(container) {
-	await stopLifecycleHooks(container);
-}
-
-//#endregion
-//#region src/index.ts
-const injeca = {
-	provide,
-	invoke,
-	resolve,
-	start,
-	stop,
-	setLogger
-};
-
-//#endregion
-export { start as _, provide$1 as a, stop$1 as c, createNoopLogger as d, invoke as f, setLogger as g, resolve as h, lifecycle as i, createDefaultLogger as l, resetContainer as m, createContainer as n, resolve$1 as o, provide as p, invoke$1 as r, start$1 as s, injeca as t, createLoggLogger as u, stop as v };
-//# sourceMappingURL=src-UXkTj4Np.mjs.map