@kaokei/di 2.0.8 → 3.0.0

package/dist/index.js

@@ -0,0 +1,402 @@
+var V = Object.defineProperty;
+var R = (e, t, n) => t in e ? V(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var a = (e, t, n) => R(e, typeof t != "symbol" ? t + "" : t, n);
+const l = {
+  // 记录构造函数参数装饰器对应的数据的key
+  INJECTED_PARAMS: "injected:params",
+  // 记录实例属性装饰器对应的数据的key
+  INJECTED_PROPS: "injected:props",
+  // Inject装饰器的key
+  INJECT: "inject",
+  // Self装饰器的key
+  SELF: "self",
+  // SkipSelf装饰器的key
+  SKIP_SELF: "skipSelf",
+  // Optional装饰器的key
+  OPTIONAL: "optional",
+  // PostConstruct装饰器的key
+  POST_CONSTRUCT: "postConstruct",
+  // PreDestroy装饰器的key
+  PRE_DESTROY: "preDestroy"
+}, p = {
+  DEFAULT: "default",
+  INITING: "initing",
+  ACTIVATED: "activated"
+}, d = {
+  Invalid: "Invalid",
+  Instance: "Instance",
+  ConstantValue: "ConstantValue",
+  DynamicValue: "DynamicValue"
+}, C = {
+  POST_CONSTRUCT: "Cannot apply @PostConstruct decorator multiple times in the same class.",
+  PRE_DESTROY: "Cannot apply @PreDestroy decorator multiple times in the same class.",
+  MISS_INJECT: "Expected a @Inject decorator to explicitly specify the token.",
+  MISS_CONTAINER: "@LazyInject decorator cannot find the corresponding container."
+}, S = Symbol(), v = /* @__PURE__ */ new WeakMap();
+function w(e) {
+  return typeof e == "function" && Object.getPrototypeOf(e) !== Function.prototype;
+}
+function A(e, t, n) {
+  const s = v.get(n) || {};
+  s[e] = t, v.set(n, s);
+}
+function I(e, t) {
+  return (v.get(t) || {})[e];
+}
+function y(e, t) {
+  const n = I(e, t);
+  if (!w(t))
+    return n;
+  const s = y(
+    e,
+    Object.getPrototypeOf(t)
+  );
+  if (s || n)
+    return {
+      ...s || {},
+      ...n || {}
+    };
+}
+class J {
+  constructor(t) {
+    a(this, "_", "");
+    a(this, "name");
+    this.name = t;
+  }
+}
+class _ {
+  constructor(t) {
+    a(this, "callback");
+    this.callback = t;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function D(e) {
+  if (!e)
+    throw new Error(C.MISS_INJECT);
+  return e instanceof _ ? e.resolve() : e;
+}
+class E extends Error {
+  constructor(t, n) {
+    super(), this.name = this.constructor.name, this.message = `${t}${n == null ? void 0 : n.name}`;
+  }
+}
+class P extends E {
+  constructor(t) {
+    super("");
+    const n = [];
+    let s = t;
+    for (; s && s.token; )
+      n.push(s.token), s = s.parent;
+    const i = n.reverse().map((o) => o.name).join(" --> ");
+    this.message = `Circular dependency found: ${i}`;
+  }
+}
+class B extends E {
+  constructor(t) {
+    super("Invalid binding: ", t);
+  }
+}
+class k extends P {
+  constructor(t) {
+    super(t), this.name = "CircularDependencyError inside @PostConstruct";
+  }
+}
+class j {
+  constructor(t, n) {
+    a(this, "container");
+    a(this, "context");
+    a(this, "token");
+    a(this, "type", d.Invalid);
+    a(this, "status", p.DEFAULT);
+    a(this, "classValue");
+    a(this, "constantValue");
+    a(this, "dynamicValue");
+    a(this, "cache");
+    a(this, "postConstructResult", S);
+    a(this, "onActivationHandler");
+    a(this, "onDeactivationHandler");
+    this.container = n, this.context = { container: this.container }, this.token = t;
+  }
+  onActivation(t) {
+    this.onActivationHandler = t;
+  }
+  onDeactivation(t) {
+    this.onDeactivationHandler = t;
+  }
+  activate(t) {
+    const n = this.onActivationHandler ? this.onActivationHandler(this.context, t) : t;
+    return this.container.activate(n, this.token);
+  }
+  deactivate() {
+    this.onDeactivationHandler && this.onDeactivationHandler(this.cache);
+  }
+  to(t) {
+    return this.type = d.Instance, this.classValue = t, this;
+  }
+  toSelf() {
+    return this.to(this.token);
+  }
+  toConstantValue(t) {
+    return this.type = d.ConstantValue, this.constantValue = t, this;
+  }
+  toDynamicValue(t) {
+    return this.type = d.DynamicValue, this.dynamicValue = t, this;
+  }
+  toService(t) {
+    return this.toDynamicValue(
+      (n) => n.container.get(t, { parent: { token: this.token } })
+    );
+  }
+  get(t) {
+    if (p.INITING === this.status)
+      throw new P(t);
+    if (p.ACTIVATED === this.status)
+      return this.cache;
+    if (d.Instance === this.type)
+      return this.resolveInstanceValue(t);
+    if (d.ConstantValue === this.type)
+      return this.resolveConstantValue();
+    if (d.DynamicValue === this.type)
+      return this.resolveDynamicValue();
+    throw new B(this.token);
+  }
+  getAwaitBindings(t, n) {
+    return n === !0 ? t : Array.isArray(n) ? t.filter((s) => n.includes(s.token)) : typeof n == "function" ? t.filter(n) : [];
+  }
+  postConstruct(t, n, s) {
+    if (d.Instance === this.type) {
+      const { key: i, value: o } = y(l.POST_CONSTRUCT, this.token) || {};
+      if (i)
+        if (o) {
+          const r = [...n, ...s].filter(
+            (u) => d.Instance === (u == null ? void 0 : u.type)
+          ), c = this.getAwaitBindings(r, o);
+          for (const u of c)
+            if (u && u.postConstructResult === S)
+              throw new k({
+                token: u.token,
+                parent: t
+              });
+          const h = c.map((u) => u.postConstructResult);
+          this.postConstructResult = Promise.all(h).then(
+            () => this.execute(i)
+          );
+        } else
+          this.postConstructResult = this.execute(i);
+      else
+        this.postConstructResult = void 0;
+    }
+  }
+  preDestroy() {
+    if (d.Instance === this.type) {
+      const { key: t } = y(l.PRE_DESTROY, this.token) || {};
+      if (t)
+        return this.execute(t);
+    }
+    this.container = null, this.context = null;
+  }
+  execute(t) {
+    const n = this.cache[t];
+    return n == null ? void 0 : n.call(this.cache);
+  }
+  resolveInstanceValue(t) {
+    this.status = p.INITING;
+    const n = this.classValue, [s, i] = this.getConstructorParameters(t), o = new n(...s);
+    this.cache = this.activate(o), this.status = p.ACTIVATED, b.set(this.cache, this.container);
+    const [r, c] = this.getInjectProperties(t);
+    return Object.assign(this.cache, r), this.postConstruct(t, i, c), this.cache;
+  }
+  resolveConstantValue() {
+    return this.status = p.INITING, this.cache = this.activate(this.constantValue), this.status = p.ACTIVATED, this.cache;
+  }
+  resolveDynamicValue() {
+    this.status = p.INITING;
+    const t = this.dynamicValue.call(this, this.context);
+    return this.cache = this.activate(t), this.status = p.ACTIVATED, this.cache;
+  }
+  getConstructorParameters(t) {
+    const n = I(l.INJECTED_PARAMS, this.classValue) || [], s = [], i = [];
+    for (let o = 0; o < n.length; o++) {
+      const r = n[o], { inject: c, ...h } = r;
+      h.parent = t;
+      const u = this.container.get(D(c), h);
+      s.push(u), i.push(h.binding);
+    }
+    return [s, i];
+  }
+  getInjectProperties(t) {
+    const n = y(l.INJECTED_PROPS, this.classValue) || {}, s = Object.keys(n), i = /* @__PURE__ */ Object.create(null), o = [];
+    for (let r = 0; r < s.length; r++) {
+      const c = s[r], h = n[c], { inject: u, ...f } = h;
+      f.parent = t;
+      const g = this.container.get(D(u), f);
+      g === void 0 && h.optional || (i[c] = g), o.push(f.binding);
+    }
+    return [i, o];
+  }
+}
+class M extends E {
+  constructor(t) {
+    super("No matching binding found for token: ", t);
+  }
+}
+class x extends E {
+  constructor(t) {
+    super("Cannot bind token multiple times: ", t);
+  }
+}
+class N {
+  constructor() {
+    a(this, "parent");
+    a(this, "bindings", /* @__PURE__ */ new Map());
+    a(this, "onActivationHandler");
+    a(this, "onDeactivationHandler");
+  }
+  bind(t) {
+    if (this.bindings.has(t))
+      throw new x(t);
+    const n = this.buildBinding(t);
+    return this.bindings.set(t, n), n;
+  }
+  unbind(t) {
+    if (this.bindings.has(t)) {
+      const n = this.getBinding(t);
+      this.deactivate(n), n.preDestroy(), this.bindings.delete(t);
+    }
+  }
+  unbindAll() {
+    this.bindings.forEach((t) => {
+      this.unbind(t.token);
+    });
+  }
+  isCurrentBound(t) {
+    return this.bindings.has(t);
+  }
+  isBound(t) {
+    return this.isCurrentBound(t) || !!this.parent && this.parent.isBound(t);
+  }
+  createChild() {
+    const t = new N();
+    return t.parent = this, t;
+  }
+  get(t, n = {}) {
+    const s = this.getBinding(t);
+    if (n.skipSelf) {
+      if (this.parent)
+        return n.skipSelf = !1, this.parent.get(t, n);
+    } else if (n.self || s) {
+      if (s)
+        return n.token = t, n.binding = s, s.get(n);
+    } else if (this.parent)
+      return this.parent.get(t, n);
+    return this.checkBindingNotFoundError(t, n);
+  }
+  onActivation(t) {
+    this.onActivationHandler = t;
+  }
+  onDeactivation(t) {
+    this.onDeactivationHandler = t;
+  }
+  activate(t, n) {
+    return this.onActivationHandler ? this.onActivationHandler({ container: this }, t, n) : t;
+  }
+  deactivate(t) {
+    this.onDeactivationHandler && this.onDeactivationHandler(t.cache, t.token), t.deactivate();
+  }
+  buildBinding(t) {
+    return new j(t, this);
+  }
+  getBinding(t) {
+    return this.bindings.get(t);
+  }
+  checkBindingNotFoundError(t, n) {
+    if (!n.optional)
+      throw new M(t);
+  }
+}
+const b = /* @__PURE__ */ new WeakMap();
+function T(e, t) {
+  return function(n) {
+    return function(s, i, o) {
+      const r = typeof o == "number", c = r ? s : s.constructor, h = r ? o : i, u = r ? l.INJECTED_PARAMS : l.INJECTED_PROPS, f = r ? I(u, c) || [] : y(u, c) || {}, g = f[h] || {};
+      g[e] = n === void 0 ? t : n, f[h] = g, A(u, f, c);
+    };
+  };
+}
+function O(e, t) {
+  return (n) => (s, i) => {
+    if (I(e, s.constructor))
+      throw new Error(t);
+    A(
+      e,
+      { key: i, value: n },
+      s.constructor
+    );
+  };
+}
+const U = T(l.INJECT), G = T(l.SELF, !0), Y = T(l.SKIP_SELF, !0), z = T(l.OPTIONAL, !0), K = O(
+  l.POST_CONSTRUCT,
+  C.POST_CONSTRUCT
+), $ = O(
+  l.PRE_DESTROY,
+  C.PRE_DESTROY
+);
+function m(e, t, n, s) {
+  for (let i = e.length - 1; i >= 0; i--)
+    e[i](t, n, s);
+}
+function W(e, t, n) {
+  e = Array.isArray(e) ? e : [e], typeof n == "number" ? m(e, t, void 0, n) : typeof n == "string" && m(e, t.prototype, n);
+}
+function H(e, t, n, s) {
+  function i() {
+    const r = Symbol.for(t);
+    if (!this.hasOwnProperty(r)) {
+      const c = s || b.get(this), h = this.constructor;
+      if (!c)
+        throw new Error(`${C.MISS_CONTAINER} ${h.name}`);
+      this[r] = c.get(D(n), {
+        parent: { token: h }
+      });
+    }
+    return this[r];
+  }
+  function o(r) {
+    const c = Symbol.for(t);
+    this[c] = r;
+  }
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !0,
+    get: i,
+    set: o
+  });
+}
+function L(e, t) {
+  return function(n, s) {
+    H(n, s, e, t);
+  };
+}
+function q(e) {
+  return function(t) {
+    return L(t, e);
+  };
+}
+export {
+  b as CONTAINER_MAP,
+  N as Container,
+  U as Inject,
+  L as LazyInject,
+  _ as LazyToken,
+  z as Optional,
+  K as PostConstruct,
+  $ as PreDestroy,
+  G as Self,
+  Y as SkipSelf,
+  J as Token,
+  q as createLazyInject,
+  W as decorate
+};

package/dist/interfaces.d.cts

@@ -0,0 +1,47 @@
+import { Token, LazyToken } from './token';
+import { Container } from './container';
+import { Binding } from './binding';
+import { KEYS } from './constants';
+export type Newable<TInstance = unknown, TArgs extends unknown[] = any[]> = new (...args: TArgs) => TInstance;
+export type InjectFunction<R extends (...args: any) => any> = (token: GenericToken) => ReturnType<R>;
+export type CommonToken<T = unknown> = Token<T> | Newable<T>;
+export type GenericToken<T = unknown> = Token<T> | Newable<T> | LazyToken<T>;
+export type LazyTokenCallback<T = unknown> = () => CommonToken<T>;
+export interface Context {
+    container: Container;
+}
+export type DynamicValue<T> = (ctx: Context) => T;
+export type RecordObject = Record<string, unknown>;
+export interface Options<T = unknown> {
+    inject?: GenericToken<T>;
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+    token?: CommonToken<T>;
+    binding?: Binding<T>;
+    parent?: Options<any>;
+}
+export type ActivationHandler<T = unknown> = (ctx: Context, input: T, token?: CommonToken<T>) => T;
+export type DeactivationHandler<T = unknown> = (input: T, token?: CommonToken<T>) => void;
+export type PostConstructParam = void | true | CommonToken[] | ((item: Binding, index: number, arr: Binding[]) => boolean);
+export type META_KEY_INJECTED_PARAMS = typeof KEYS.INJECTED_PARAMS;
+export type META_KEY_INJECTED_PROPS = typeof KEYS.INJECTED_PROPS;
+export type META_KEY_POST_CONSTRUCT = typeof KEYS.POST_CONSTRUCT;
+export type META_KEY_PRE_DESTROY = typeof KEYS.PRE_DESTROY;
+export type META_KEYS = META_KEY_INJECTED_PARAMS | META_KEY_INJECTED_PROPS | META_KEY_POST_CONSTRUCT | META_KEY_PRE_DESTROY;
+export type META_VALUE_INJECTED_PARAMS = Options[];
+export type META_VALUE_INJECTED_PROPS = Record<string, Options>;
+export type META_VALUE_POST_CONSTRUCT = KV<PostConstructParam>;
+export type META_VALUE_PRE_DESTROY = KV<void>;
+export type META_VALUES = META_VALUE_INJECTED_PARAMS | META_VALUE_INJECTED_PROPS | META_VALUE_POST_CONSTRUCT | META_VALUE_PRE_DESTROY;
+export interface KV<T> {
+    key: string;
+    value: T;
+}
+export type ExtractKV<T> = T extends META_KEY_POST_CONSTRUCT ? PostConstructParam : T extends META_KEY_PRE_DESTROY ? void : never;
+export interface CacheMapValue {
+    [KEYS.INJECTED_PARAMS]: Options[];
+    [KEYS.INJECTED_PROPS]: Record<string, Options>;
+    [KEYS.POST_CONSTRUCT]: KV<PostConstructParam>;
+    [KEYS.PRE_DESTROY]: KV<void>;
+}

package/dist/interfaces.d.ts

@@ -0,0 +1,47 @@
+import { Token, LazyToken } from './token';
+import { Container } from './container';
+import { Binding } from './binding';
+import { KEYS } from './constants';
+export type Newable<TInstance = unknown, TArgs extends unknown[] = any[]> = new (...args: TArgs) => TInstance;
+export type InjectFunction<R extends (...args: any) => any> = (token: GenericToken) => ReturnType<R>;
+export type CommonToken<T = unknown> = Token<T> | Newable<T>;
+export type GenericToken<T = unknown> = Token<T> | Newable<T> | LazyToken<T>;
+export type LazyTokenCallback<T = unknown> = () => CommonToken<T>;
+export interface Context {
+    container: Container;
+}
+export type DynamicValue<T> = (ctx: Context) => T;
+export type RecordObject = Record<string, unknown>;
+export interface Options<T = unknown> {
+    inject?: GenericToken<T>;
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+    token?: CommonToken<T>;
+    binding?: Binding<T>;
+    parent?: Options<any>;
+}
+export type ActivationHandler<T = unknown> = (ctx: Context, input: T, token?: CommonToken<T>) => T;
+export type DeactivationHandler<T = unknown> = (input: T, token?: CommonToken<T>) => void;
+export type PostConstructParam = void | true | CommonToken[] | ((item: Binding, index: number, arr: Binding[]) => boolean);
+export type META_KEY_INJECTED_PARAMS = typeof KEYS.INJECTED_PARAMS;
+export type META_KEY_INJECTED_PROPS = typeof KEYS.INJECTED_PROPS;
+export type META_KEY_POST_CONSTRUCT = typeof KEYS.POST_CONSTRUCT;
+export type META_KEY_PRE_DESTROY = typeof KEYS.PRE_DESTROY;
+export type META_KEYS = META_KEY_INJECTED_PARAMS | META_KEY_INJECTED_PROPS | META_KEY_POST_CONSTRUCT | META_KEY_PRE_DESTROY;
+export type META_VALUE_INJECTED_PARAMS = Options[];
+export type META_VALUE_INJECTED_PROPS = Record<string, Options>;
+export type META_VALUE_POST_CONSTRUCT = KV<PostConstructParam>;
+export type META_VALUE_PRE_DESTROY = KV<void>;
+export type META_VALUES = META_VALUE_INJECTED_PARAMS | META_VALUE_INJECTED_PROPS | META_VALUE_POST_CONSTRUCT | META_VALUE_PRE_DESTROY;
+export interface KV<T> {
+    key: string;
+    value: T;
+}
+export type ExtractKV<T> = T extends META_KEY_POST_CONSTRUCT ? PostConstructParam : T extends META_KEY_PRE_DESTROY ? void : never;
+export interface CacheMapValue {
+    [KEYS.INJECTED_PARAMS]: Options[];
+    [KEYS.INJECTED_PROPS]: Record<string, Options>;
+    [KEYS.POST_CONSTRUCT]: KV<PostConstructParam>;
+    [KEYS.PRE_DESTROY]: KV<void>;
+}

package/dist/lazyinject.d.cts

@@ -0,0 +1,4 @@
+import { GenericToken } from './interfaces';
+import { Container } from './container';
+export declare function LazyInject<T>(token: GenericToken<T>, container?: Container): (proto: any, key: string) => void;
+export declare function createLazyInject(container: Container): <T>(token: GenericToken<T>) => (proto: any, key: string) => void;

package/dist/lazyinject.d.ts

@@ -0,0 +1,4 @@
+import { GenericToken } from './interfaces';
+import { Container } from './container';
+export declare function LazyInject<T>(token: GenericToken<T>, container?: Container): (proto: any, key: string) => void;
+export declare function createLazyInject(container: Container): <T>(token: GenericToken<T>) => (proto: any, key: string) => void;

package/dist/token.d.cts

@@ -0,0 +1,12 @@
+import { GenericToken, LazyTokenCallback } from './interfaces';
+export declare class Token<T> {
+    _: T;
+    name: string;
+    constructor(name: string);
+}
+export declare class LazyToken<T> {
+    private callback;
+    constructor(callback: LazyTokenCallback<T>);
+    resolve(): import('./interfaces').CommonToken<T>;
+}
+export declare function resolveToken<T>(token?: GenericToken<T>): import('./interfaces').CommonToken<T>;

package/dist/token.d.ts

@@ -0,0 +1,12 @@
+import { GenericToken, LazyTokenCallback } from './interfaces';
+export declare class Token<T> {
+    _: T;
+    name: string;
+    constructor(name: string);
+}
+export declare class LazyToken<T> {
+    private callback;
+    constructor(callback: LazyTokenCallback<T>);
+    resolve(): import('./interfaces').CommonToken<T>;
+}
+export declare function resolveToken<T>(token?: GenericToken<T>): import('./interfaces').CommonToken<T>;