@fluixi/di 0.0.0-stage → 1.0.0-alpha.99

package/dist/inject.d.ts

@@ -0,0 +1,151 @@
+import { Injector } from './injector.js';
+import type { InjectOptions, Provider } from './provider.js';
+import type { Token } from './token.js';
+/**
+ * Resolve `token` from the current injection context: the injector set by
+ * {@link runInInjectionContext} or building the current service, else the nearest component
+ * injector up the reactive owner tree, else the root (the request's on the server, the app's in
+ * the browser).
+ *
+ * Call it during a component's setup, inside a provider's constructor or factory, or inside
+ * {@link runInInjectionContext}. In an event handler or after an `await` there is no component
+ * owner any more: keep the value, or the injector (`inject(INJECTOR)`), from setup instead.
+ *
+ * @param token - What to resolve.
+ * @param options - Where to look and what to do when nothing is found; see {@link InjectOptions}.
+ * @returns The value, or `null` when `optional` is set and nothing provides the token.
+ * @throws {@link InjectionError} When nothing provides the token, or on a dependency cycle.
+ *
+ * @example
+ * ```ts
+ * function Profile() {
+ *   const users = inject(Users);
+ *   const analytics = inject(Analytics, { optional: true }); // null where not provided
+ *   ...
+ * }
+ * ```
+ */
+export declare function inject<T>(token: Token<T>, options: InjectOptions & {
+    optional: true;
+}): T | null;
+export declare function inject<T>(token: Token<T>, options?: InjectOptions): T;
+/**
+ * Provide services to the current component and its descendants. The first call in a component
+ * creates its injector, below the nearest ancestor component's injector (or the root); later
+ * calls add to it. The injector is disposed when the component unmounts: hooks registered on its
+ * `DestroyRef` and each service's `onDestroy()` run then.
+ *
+ * @param providers - The providers to add to the component's injector.
+ * @returns The component's injector.
+ * @throws Error When called outside a component, where there is no owner to attach to; use
+ *   {@link provideRoot} for services of the whole app.
+ *
+ * @example
+ * ```ts
+ * function Checkout() {
+ *   provide([{ provide: Cart, useClass: CartStore }]); // one cart per checkout, released with it
+ *   return <CheckoutSteps />;
+ * }
+ * ```
+ */
+export declare function provide(providers: ReadonlyArray<Provider>): Injector;
+/**
+ * Provide services to the whole app, in the root injector: one instance per request on the
+ * server (released when the request ends, so per-user state never leaks between requests), one
+ * per app in the browser.
+ *
+ * Call it at module load, before the first render: in an app module's providers, or in the app's
+ * entry. Providers added later reach the browser's root and the current request's root, not
+ * requests already finished.
+ *
+ * @param providers - The providers every root injector starts with.
+ *
+ * @example
+ * ```ts
+ * provideRoot([
+ *   { provide: ApiUrl, useValue: import.meta.env.API_URL },
+ *   { provide: Http, useClass: FetchHttp, deps: [ApiUrl] },
+ * ]);
+ * ```
+ */
+export declare function provideRoot(providers: ReadonlyArray<Provider>): void;
+/**
+ * Provide services once per process, in the platform injector above every root: shared by every
+ * request on the server. For what is costly to create and safe to share (a connection pool,
+ * parsed settings); never for per-user state, which belongs in {@link provideRoot}.
+ *
+ * @param providers - The providers the platform injector holds.
+ *
+ * @example
+ * ```ts
+ * providePlatform([{ provide: Database, useFactory: () => createPool(process.env.DATABASE_URL) }]);
+ * ```
+ */
+export declare function providePlatform(providers: ReadonlyArray<Provider>): void;
+/**
+ * Run `fn` with `injector` as the injection context, so `inject()` inside it resolves from
+ * `injector`. The context lasts for the synchronous part of `fn`: after an `await`, resolve what
+ * is needed before it, or call this again.
+ *
+ * @param injector - Where `inject()` resolves from while `fn` runs.
+ * @param fn - The work to run.
+ * @returns What `fn` returns.
+ *
+ * @example
+ * ```ts
+ * const injector = inject(INJECTOR);
+ * button.addEventListener('click', () => runInInjectionContext(injector, () => inject(Cart).add(item)));
+ * ```
+ */
+export declare function runInInjectionContext<R>(injector: Injector, fn: () => R): R;
+/**
+ * Whether `inject()` can resolve here: inside {@link runInInjectionContext} or a provider being
+ * built, during a component's setup, or during a server request.
+ *
+ * @returns `true` when an injection context is active.
+ */
+export declare function isInInjectionContext(): boolean;
+/**
+ * Throw unless an injection context is active. For functions that call `inject()` themselves and
+ * want a clear error for their own callers instead of an unexpected resolution from the root.
+ *
+ * @param name - The calling function's name, used in the message.
+ * @throws Error When no injection context is active.
+ *
+ * @example
+ * ```ts
+ * export function useCart(): Cart {
+ *   assertInInjectionContext('useCart');
+ *   return inject(Cart);
+ * }
+ * ```
+ */
+export declare function assertInInjectionContext(name: string): void;
+/**
+ * The injector of the current context: to keep, and resolve from or hand to
+ * {@link runInInjectionContext} later. Same as `inject(INJECTOR)`.
+ *
+ * @returns The injector `inject()` would resolve from here.
+ */
+export declare function getInjector(): Injector;
+/**
+ * Create a standalone injector holding `providers`, below `parent`. For a scope of your own (a
+ * job, a dialog, a test): what it builds is released when you call `dispose()` on it.
+ *
+ * @param providers - The providers the new injector holds.
+ * @param parent - Where unresolved tokens are looked for next. Defaults to the current root;
+ *   `null` makes it the top of its own chain.
+ * @returns The new injector.
+ *
+ * @example
+ * ```ts
+ * const job = createInjector([{ provide: JobId, useValue: id }]);
+ * try {
+ *   await runInInjectionContext(job, () => inject(Importer)).run();
+ * } finally {
+ *   job.dispose();
+ * }
+ * ```
+ */
+export declare function createInjector(providers: ReadonlyArray<Provider>, parent?: Injector | null): Injector;
+//# sourceMappingURL=inject.d.ts.map

package/dist/inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../src/inject.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAAG,CAAC,GAAG,IAAI,CAAC;AAClG,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,CAAC,CAAC;AAKvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAapE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI,CAKpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI,CAGxE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ3E;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAEtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,CAErG"}

package/dist/inject.js

@@ -0,0 +1,174 @@
+/**
+ * What code calls: resolve from the current context, provide to a component, the whole app or
+ * the process, and work with the injection context.
+ *
+ * @module
+ */
+import { getRequestContext } from '@fluixi/dom';
+import { getOwner, onCleanup } from '@fluixi/reactive/signal';
+import { currentInjector, nearestOwnerInjector, rootInjector } from './hierarchy.js';
+import { Injector } from './injector.js';
+import { state } from './state.js';
+export function inject(token, options) {
+    return currentInjector().get(token, options ?? {});
+}
+/**
+ * Provide services to the current component and its descendants. The first call in a component
+ * creates its injector, below the nearest ancestor component's injector (or the root); later
+ * calls add to it. The injector is disposed when the component unmounts: hooks registered on its
+ * `DestroyRef` and each service's `onDestroy()` run then.
+ *
+ * @param providers - The providers to add to the component's injector.
+ * @returns The component's injector.
+ * @throws Error When called outside a component, where there is no owner to attach to; use
+ *   {@link provideRoot} for services of the whole app.
+ *
+ * @example
+ * ```ts
+ * function Checkout() {
+ *   provide([{ provide: Cart, useClass: CartStore }]); // one cart per checkout, released with it
+ *   return <CheckoutSteps />;
+ * }
+ * ```
+ */
+export function provide(providers) {
+    const owner = getOwner();
+    if (!owner) {
+        throw new Error('[fluixi/di] provide() runs inside a component. Use provideRoot() for services of the whole app.');
+    }
+    let inj = state.ownerInjectors.get(owner);
+    if (!inj) {
+        const created = new Injector(nearestOwnerInjector(owner.parent) ?? rootInjector(), 'owner');
+        state.ownerInjectors.set(owner, created);
+        onCleanup(() => created.dispose());
+        inj = created;
+    }
+    return inj.register(providers);
+}
+/**
+ * Provide services to the whole app, in the root injector: one instance per request on the
+ * server (released when the request ends, so per-user state never leaks between requests), one
+ * per app in the browser.
+ *
+ * Call it at module load, before the first render: in an app module's providers, or in the app's
+ * entry. Providers added later reach the browser's root and the current request's root, not
+ * requests already finished.
+ *
+ * @param providers - The providers every root injector starts with.
+ *
+ * @example
+ * ```ts
+ * provideRoot([
+ *   { provide: ApiUrl, useValue: import.meta.env.API_URL },
+ *   { provide: Http, useClass: FetchHttp, deps: [ApiUrl] },
+ * ]);
+ * ```
+ */
+export function provideRoot(providers) {
+    state.rootProviders.push(...providers);
+    state.clientRoot?.register(providers);
+    const ctx = getRequestContext();
+    if (ctx)
+        state.requestRoots.get(ctx)?.register(providers);
+}
+/**
+ * Provide services once per process, in the platform injector above every root: shared by every
+ * request on the server. For what is costly to create and safe to share (a connection pool,
+ * parsed settings); never for per-user state, which belongs in {@link provideRoot}.
+ *
+ * @param providers - The providers the platform injector holds.
+ *
+ * @example
+ * ```ts
+ * providePlatform([{ provide: Database, useFactory: () => createPool(process.env.DATABASE_URL) }]);
+ * ```
+ */
+export function providePlatform(providers) {
+    state.platformProviders.push(...providers);
+    state.platform?.register(providers);
+}
+/**
+ * Run `fn` with `injector` as the injection context, so `inject()` inside it resolves from
+ * `injector`. The context lasts for the synchronous part of `fn`: after an `await`, resolve what
+ * is needed before it, or call this again.
+ *
+ * @param injector - Where `inject()` resolves from while `fn` runs.
+ * @param fn - The work to run.
+ * @returns What `fn` returns.
+ *
+ * @example
+ * ```ts
+ * const injector = inject(INJECTOR);
+ * button.addEventListener('click', () => runInInjectionContext(injector, () => inject(Cart).add(item)));
+ * ```
+ */
+export function runInInjectionContext(injector, fn) {
+    const previous = state.explicit;
+    state.explicit = injector;
+    try {
+        return fn();
+    }
+    finally {
+        state.explicit = previous;
+    }
+}
+/**
+ * Whether `inject()` can resolve here: inside {@link runInInjectionContext} or a provider being
+ * built, during a component's setup, or during a server request.
+ *
+ * @returns `true` when an injection context is active.
+ */
+export function isInInjectionContext() {
+    return state.explicit !== null || getOwner() !== null || getRequestContext() !== undefined;
+}
+/**
+ * Throw unless an injection context is active. For functions that call `inject()` themselves and
+ * want a clear error for their own callers instead of an unexpected resolution from the root.
+ *
+ * @param name - The calling function's name, used in the message.
+ * @throws Error When no injection context is active.
+ *
+ * @example
+ * ```ts
+ * export function useCart(): Cart {
+ *   assertInInjectionContext('useCart');
+ *   return inject(Cart);
+ * }
+ * ```
+ */
+export function assertInInjectionContext(name) {
+    if (!isInInjectionContext()) {
+        throw new Error(`[fluixi/di] ${name}() runs inside a component, a request or runInInjectionContext().`);
+    }
+}
+/**
+ * The injector of the current context: to keep, and resolve from or hand to
+ * {@link runInInjectionContext} later. Same as `inject(INJECTOR)`.
+ *
+ * @returns The injector `inject()` would resolve from here.
+ */
+export function getInjector() {
+    return currentInjector();
+}
+/**
+ * Create a standalone injector holding `providers`, below `parent`. For a scope of your own (a
+ * job, a dialog, a test): what it builds is released when you call `dispose()` on it.
+ *
+ * @param providers - The providers the new injector holds.
+ * @param parent - Where unresolved tokens are looked for next. Defaults to the current root;
+ *   `null` makes it the top of its own chain.
+ * @returns The new injector.
+ *
+ * @example
+ * ```ts
+ * const job = createInjector([{ provide: JobId, useValue: id }]);
+ * try {
+ *   await runInInjectionContext(job, () => inject(Importer)).run();
+ * } finally {
+ *   job.dispose();
+ * }
+ * ```
+ */
+export function createInjector(providers, parent) {
+    return new Injector(parent === undefined ? rootInjector() : parent, 'standalone').register(providers);
+}

package/dist/inject.mjs

@@ -0,0 +1,332 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/inject.ts
+import { getRequestContext as getRequestContext2 } from "@fluixi/dom";
+import { getOwner as getOwner2, onCleanup } from "@fluixi/reactive/signal";
+
+// src/hierarchy.ts
+import { getRequestContext, onRequestEnd } from "@fluixi/dom";
+import { getOwner } from "@fluixi/reactive/signal";
+
+// src/injector.ts
+import { openReactiveScope, withReactiveScope } from "@fluixi/reactive/signal";
+
+// src/errors.ts
+var InjectionError = class extends Error {
+  /**
+   * @param message - What went wrong, with the path rendered into it.
+   * @param path - The tokens being resolved, outermost first; the last one is the one that failed.
+   */
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "InjectionError";
+  }
+};
+
+// src/state.ts
+function freshState() {
+  return {
+    platformProviders: [],
+    rootProviders: [],
+    platform: null,
+    clientRoot: null,
+    requestRoots: /* @__PURE__ */ new WeakMap(),
+    ownerInjectors: /* @__PURE__ */ new WeakMap(),
+    moduleScopes: /* @__PURE__ */ new WeakMap(),
+    overrides: /* @__PURE__ */ new Map(),
+    explicit: null,
+    path: []
+  };
+}
+var state = globalThis[/* @__PURE__ */ Symbol.for("fluixi.di")] ??= freshState();
+
+// src/token.ts
+function injectionToken(name, options) {
+  return { id: Symbol(name), name, factory: options?.factory, scope: options?.scope ?? "root" };
+}
+
+// src/tokens.ts
+var DestroyRef = injectionToken("DestroyRef");
+var INJECTOR = injectionToken("Injector");
+
+// src/injector.ts
+var _records, _created, _hooks, _destroyed, _Injector_instances, home_fn, fromProvider_fn, build_fn, make_fn;
+var Injector = class {
+  /**
+   * @param parent - Where a token this injector does not hold is looked for next; `null` for the
+   *   top of a chain.
+   * @param kind - Where the injector sits in the hierarchy; see {@link InjectorKind}.
+   */
+  constructor(parent = null, kind = "standalone") {
+    this.parent = parent;
+    this.kind = kind;
+    __privateAdd(this, _Injector_instances);
+    __privateAdd(this, _records, /* @__PURE__ */ new Map());
+    __privateAdd(this, _created, []);
+    __privateAdd(this, _hooks, []);
+    __privateAdd(this, _destroyed, false);
+    const self = this;
+    this.destroyRef = {
+      onDestroy(fn) {
+        __privateGet(self, _hooks).push(fn);
+        return () => {
+          const i = __privateGet(self, _hooks).indexOf(fn);
+          if (i >= 0) __privateGet(self, _hooks).splice(i, 1);
+        };
+      },
+      get destroyed() {
+        return __privateGet(self, _destroyed);
+      }
+    };
+  }
+  /** Whether {@link Injector.dispose} has run. A disposed injector refuses every `get`. */
+  get destroyed() {
+    return __privateGet(this, _destroyed);
+  }
+  /**
+   * Add providers to this injector. A provider for a token already held replaces it, except
+   * `multi` providers, which extend the token's list. A provider whose token has a test override
+   * is replaced by the override.
+   *
+   * @param providers - The providers to add, in order.
+   * @returns This injector, for chaining.
+   */
+  register(providers) {
+    for (const given of providers) {
+      const p = state.overrides.get(given.provide.id) ?? given;
+      if (p.multi) {
+        const rec = __privateGet(this, _records).get(p.provide.id);
+        if (rec?.multi) {
+          rec.providers.push(p);
+          rec.built = false;
+        } else __privateGet(this, _records).set(p.provide.id, { multi: true, providers: [p], built: false, building: false, value: [] });
+      } else {
+        __privateGet(this, _records).set(p.provide.id, { multi: false, provider: p, built: false, building: false, value: void 0 });
+      }
+    }
+    return this;
+  }
+  get(token, options = {}) {
+    var _a, _b, _c;
+    if (__privateGet(this, _destroyed)) throw new InjectionError(`[fluixi/di] "${token.name}" requested from a disposed injector.`, [...state.path, token.name]);
+    if (token.id === INJECTOR.id) return this;
+    if (token.id === DestroyRef.id) return this.destroyRef;
+    let inj = options.skipSelf ? this.parent : this;
+    while (inj) {
+      const rec = __privateGet(inj, _records).get(token.id);
+      if (rec) return __privateMethod(_a = inj, _Injector_instances, build_fn).call(_a, token, rec);
+      if (options.self || options.host && inj.kind === "owner") break;
+      inj = inj.parent;
+    }
+    const override = state.overrides.get(token.id);
+    if (override && !options.self) return __privateMethod(_b = __privateMethod(this, _Injector_instances, home_fn).call(this, token.scope), _Injector_instances, fromProvider_fn).call(_b, token, override);
+    if (token.factory && !options.self && !options.host) {
+      return __privateMethod(_c = __privateMethod(this, _Injector_instances, home_fn).call(this, token.scope), _Injector_instances, fromProvider_fn).call(_c, token, { provide: token, useFactory: token.factory });
+    }
+    if (options.optional) return null;
+    const path = [...state.path, token.name];
+    throw new InjectionError(
+      `[fluixi/di] No provider for "${token.name}" (${path.join(" → ")}). Provide it in an app module, with provide() or provideRoot(), or give the token a { factory }.`,
+      path
+    );
+  }
+  /**
+   * Release this injector: run the hooks registered on its `DestroyRef`, latest first, then the
+   * `onDestroy()` method of every service it built, latest built first, then forget its
+   * providers. A hook or `onDestroy()` that throws is logged and the rest still run. Running it
+   * again does nothing.
+   *
+   * Component injectors are disposed when the component unmounts, request roots when the request
+   * ends; call it yourself only for injectors you created.
+   */
+  dispose() {
+    if (__privateGet(this, _destroyed)) return;
+    __privateSet(this, _destroyed, true);
+    const fail = (error) => console.error("[fluixi/di] a destroy hook threw:", error);
+    for (const hook of __privateGet(this, _hooks).splice(0).reverse()) {
+      try {
+        hook();
+      } catch (error) {
+        fail(error);
+      }
+    }
+    for (const value of __privateGet(this, _created).splice(0).reverse()) {
+      const service = value;
+      if (service && typeof service.onDestroy === "function") {
+        try {
+          service.onDestroy();
+        } catch (error) {
+          fail(error);
+        }
+      }
+    }
+    __privateGet(this, _records).clear();
+  }
+};
+_records = new WeakMap();
+_created = new WeakMap();
+_hooks = new WeakMap();
+_destroyed = new WeakMap();
+_Injector_instances = new WeakSet();
+/** The injector a self-providing token builds in: the nearest root, or the platform. */
+home_fn = function(scope) {
+  let inj = this;
+  if (scope === "platform") {
+    while (inj.parent) inj = inj.parent;
+    return inj.kind === "platform" ? inj : platformInjector();
+  }
+  let probe = this;
+  while (probe) {
+    if (probe.kind === "root") return probe;
+    probe = probe.parent;
+  }
+  while (inj.parent && inj.parent.kind !== "platform") inj = inj.parent;
+  return inj;
+};
+fromProvider_fn = function(token, provider) {
+  let rec = __privateGet(this, _records).get(token.id);
+  if (!rec) {
+    rec = { multi: false, provider, built: false, building: false, value: void 0 };
+    __privateGet(this, _records).set(token.id, rec);
+  }
+  return __privateMethod(this, _Injector_instances, build_fn).call(this, token, rec);
+};
+build_fn = function(token, rec) {
+  if (rec.built) return rec.value;
+  if (rec.building) {
+    const path = [...state.path, token.name];
+    throw new InjectionError(`[fluixi/di] Circular dependency: ${path.join(" → ")}.`, path);
+  }
+  rec.building = true;
+  state.path.push(token.name);
+  const previous = state.explicit;
+  state.explicit = this;
+  try {
+    if (rec.multi) {
+      rec.value = rec.providers.map((p) => __privateMethod(this, _Injector_instances, make_fn).call(this, token, p));
+    } else {
+      const module = state.moduleScopes.get(rec.provider);
+      rec.value = module ? withReactiveScope(module, () => __privateMethod(this, _Injector_instances, make_fn).call(this, token, rec.provider)) : __privateMethod(this, _Injector_instances, make_fn).call(this, token, rec.provider);
+    }
+    rec.built = true;
+    return rec.value;
+  } finally {
+    state.explicit = previous;
+    state.path.pop();
+    rec.building = false;
+  }
+};
+make_fn = function(token, p) {
+  if ("useValue" in p) return p.useValue;
+  if ("useExisting" in p) return this.get(p.useExisting);
+  const deps = (p.deps ?? []).map((d) => "token" in d ? this.get(d.token, d) : this.get(d));
+  const scope = openReactiveScope({ kind: "service", name: token.name, detail: "useClass" in p ? "useClass" : "useFactory" });
+  const value = withReactiveScope(scope, () => "useClass" in p ? new p.useClass(...deps) : p.useFactory(...deps));
+  __privateGet(this, _created).push(value);
+  return value;
+};
+
+// src/hierarchy.ts
+function platformInjector() {
+  return state.platform ??= new Injector(null, "platform").register(state.platformProviders);
+}
+function rootInjector() {
+  const ctx = getRequestContext();
+  if (ctx) {
+    let inj = state.requestRoots.get(ctx);
+    if (!inj) {
+      const root = new Injector(platformInjector(), "root").register(state.rootProviders);
+      state.requestRoots.set(ctx, root);
+      onRequestEnd(() => {
+        state.requestRoots.delete(ctx);
+        root.dispose();
+      });
+      inj = root;
+    }
+    return inj;
+  }
+  return state.clientRoot ??= new Injector(platformInjector(), "root").register(state.rootProviders);
+}
+function nearestOwnerInjector(owner) {
+  let o = owner;
+  while (o) {
+    const inj = state.ownerInjectors.get(o);
+    if (inj) return inj;
+    o = o.parent;
+  }
+  return null;
+}
+function currentInjector() {
+  return state.explicit ?? nearestOwnerInjector(getOwner()) ?? rootInjector();
+}
+
+// src/inject.ts
+function inject(token, options) {
+  return currentInjector().get(token, options ?? {});
+}
+function provide(providers) {
+  const owner = getOwner2();
+  if (!owner) {
+    throw new Error("[fluixi/di] provide() runs inside a component. Use provideRoot() for services of the whole app.");
+  }
+  let inj = state.ownerInjectors.get(owner);
+  if (!inj) {
+    const created = new Injector(nearestOwnerInjector(owner.parent) ?? rootInjector(), "owner");
+    state.ownerInjectors.set(owner, created);
+    onCleanup(() => created.dispose());
+    inj = created;
+  }
+  return inj.register(providers);
+}
+function provideRoot(providers) {
+  state.rootProviders.push(...providers);
+  state.clientRoot?.register(providers);
+  const ctx = getRequestContext2();
+  if (ctx) state.requestRoots.get(ctx)?.register(providers);
+}
+function providePlatform(providers) {
+  state.platformProviders.push(...providers);
+  state.platform?.register(providers);
+}
+function runInInjectionContext(injector, fn) {
+  const previous = state.explicit;
+  state.explicit = injector;
+  try {
+    return fn();
+  } finally {
+    state.explicit = previous;
+  }
+}
+function isInInjectionContext() {
+  return state.explicit !== null || getOwner2() !== null || getRequestContext2() !== void 0;
+}
+function assertInInjectionContext(name) {
+  if (!isInInjectionContext()) {
+    throw new Error(`[fluixi/di] ${name}() runs inside a component, a request or runInInjectionContext().`);
+  }
+}
+function getInjector() {
+  return currentInjector();
+}
+function createInjector(providers, parent) {
+  return new Injector(parent === void 0 ? rootInjector() : parent, "standalone").register(providers);
+}
+export {
+  assertInInjectionContext,
+  createInjector,
+  getInjector,
+  inject,
+  isInInjectionContext,
+  provide,
+  providePlatform,
+  provideRoot,
+  runInInjectionContext
+};