plugin-tls 3.6.0 → 4.0.1

package/dist/createTierModeOptionsPluginHost-CeND_z6P.js

@@ -0,0 +1,852 @@
+import { Destroyable as m, createDestroyableSubClass as U } from "@gby/destroyable";
+import { deepmergeInto as c, deepmerge as M } from "deepmerge-ts";
+import { serialCallFuns as h } from "com-tools";
+const x = ["onCreate", "onInit", "onDestroy"];
+function E(i) {
+  const t = { ...i };
+  for (const e of x)
+    typeof t[e] == "function" && delete t[e];
+  return t;
+}
+function w(i, t) {
+  let e = Object.getOwnPropertyDescriptors(t);
+  for (const n of x)
+    typeof t[n] == "function" && delete e[n];
+  return Object.defineProperties(i, e), i;
+}
+function N(i) {
+  return i && typeof i.onUse == "function";
+}
+const a = /* @__PURE__ */ Symbol("extend");
+class d extends m {
+  /**
+   * 插件的宿主
+   */
+  host;
+  /**
+   * 所有注册的插件
+   */
+  plugins = /* @__PURE__ */ new Map();
+  /**
+   * @param host - 插件的宿主
+   */
+  constructor(t) {
+    super(), t && (this.host = t);
+  }
+  destroyThis() {
+    return this.plugins.clear(), this.host = null, super.destroyThis();
+  }
+  /**
+   * 是否注册了插件 或 扩展
+   * @param plugin - 插件 或 扩展
+   * @returns 是否注册了插件 或 扩展
+   */
+  hasUsed(t) {
+    return this.plugins.has(t);
+  }
+  /**
+   * 判断一个对象是否是插件
+   * @param target 
+   * @returns 
+   */
+  isPlugin(t) {
+    const { plugins: e } = this;
+    return e.has(t) ? e.get(t) !== a : N(t);
+  }
+  /**
+   * 使用插件、注册插件
+   * @param ext - 插件
+   * @param args - 传递给插件的选项
+   */
+  useExtend(t) {
+    const { plugins: e } = this;
+    return e.has(t) ? e.get(t) : (w(this.host.prototype, t), e.set(t, a), t);
+  }
+  /**
+   * 插件宿主实例的注册插件的方法
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IExtend.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUseExtend(t, e, ...n) {
+    const { plugins: s } = this;
+    return s.has(e) ? s.get(e) : (this.useExtend(e), e.onCreate?.call(t, t, ...n), e);
+  }
+  /**
+   * 使用插件、注册插件
+   * @param plugin - 插件
+   * @param args - 传递给插件的选项
+   */
+  usePlugin(t, ...e) {
+    const { plugins: n } = this;
+    if (n.has(t)) return n.get(t);
+    const s = t.onUse(this.host, ...e);
+    return n.set(t, s), s;
+  }
+  /**
+   * 插件宿主实例的注册插件的方法
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUsePlugin(t, e, ...n) {
+    const { plugins: s } = this;
+    if (s.has(e)) return s.get(e);
+    const o = this.usePlugin(e, ...n);
+    return e.onCreate?.(t), o;
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onCreate} 方法
+   * 如果插件的 created 方法返回 Promise，则会等待 Promise  resolve
+   * @param hostInst - 插件宿主的新实例
+   */
+  onCreate(t, ...e) {
+    const n = [];
+    for (const [s, o] of this.plugins)
+      if (s.onCreate) {
+        const r = o === a ? s.onCreate : s.onCreate.bind(s);
+        n.push(r);
+      }
+    return h(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onCreate } 方法
+   * @param hostInst - 插件宿主的新实例
+   * @param args - 初始化宿主实例时的参数
+   */
+  onInit(t, ...e) {
+    const n = [];
+    for (const [s, o] of this.plugins)
+      if (s.onInit) {
+        const r = o === a ? s.onInit : s.onInit.bind(s);
+        n.push(r);
+      }
+    return h(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主被销毁时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onDestroy} 方法
+   * @param hostInst - 被销毁的插件实例
+   */
+  onDestroy(t) {
+    const e = [];
+    for (const [n, s] of this.plugins)
+      if (n.onDestroy) {
+        const o = s === a ? n.onDestroy : n.onDestroy.bind(n);
+        e.push(o);
+      }
+    return e.reverse(), h(e, t, [t]);
+  }
+}
+function y(i) {
+  const t = i.split(".");
+  return t[0] === "" && t.shift(), t;
+}
+function f(i, t) {
+  for (const e of t)
+    if (i = i[e], i == null) return;
+  return i;
+}
+function k(i, t) {
+  return f(i, y(t));
+}
+function P(i, t, e) {
+  const n = t.pop(), s = t.length;
+  let o = 0;
+  for (; o < s; ) {
+    const r = i[t[o]];
+    if (r == null) break;
+    i = r, o++;
+  }
+  t = t.slice(o);
+  for (const r of t)
+    i = i[r] = {};
+  return i[n] = e, i;
+}
+function H(i, t, e) {
+  return P(i, y(t), e);
+}
+const g = {
+  UndefinedAndNull: function(t) {
+    return t == null;
+  },
+  Undefined: function(t) {
+    return t === void 0;
+  },
+  Null: function(t) {
+    return t === null;
+  }
+};
+class _ {
+  /**
+   * 是否要冻结 fullOption 的成员
+   * @remarks
+   * 只会冻结 fullOption 的直接成员的值，不会冻结 fullOption 孙子成员的值
+   */
+  freezeMember = !0;
+  /**
+   * 可更新顶级成员值的完整的选项
+   * @remarks
+   * 合并后的选项；
+   * plainFullOption 的代理对象，自动监听了顶层成员的屐；所以可以更改顶级成员的值，不可以更改非顶级成员的值；
+   */
+  fullOption = new Proxy(this, {
+    // @ts-ignore
+    get: function(t, e, n) {
+      const s = t.plainFullOption[e];
+      return t.freezeMember ? Object.freeze(s) : s;
+    },
+    // @ts-ignore
+    set: function(t, e, n, s) {
+      return t.setMember(e, n, !1), !0;
+    },
+    // @ts-ignore
+    has: function(t, e) {
+      return e in t.plainFullOption;
+    },
+    // @ts-ignore
+    getOwnPropertyDescriptor: function(t, e) {
+      return Object.getOwnPropertyDescriptor(t.plainFullOption, e);
+    },
+    // @ts-ignore
+    ownKeys: function(t) {
+      return Reflect.ownKeys(t.plainFullOption);
+    },
+    // @ts-ignore
+    deleteProperty: function(t, e) {
+      return t.setMember(e, void 0), !0;
+    },
+    // @ts-ignore
+    defineProperty: function(t, e, n) {
+      return Object.defineProperty(t.option, e, n), !0;
+    }
+  });
+  /**
+   * 设置选项
+   * @remarks
+   * 会将被设置的选项浅合并进当前选项中
+   * @param option 
+   * @param deep - 是否要进行深度合并 
+   */
+  setOption(t, e) {
+    const n = e ? c(this.option, t) : Object.assign(this.option, t);
+    return this.updateFullOption(), n;
+  }
+  /**
+   * 未定义值的类型
+   */
+  get undefinedValue() {
+    return this._undefinedValue;
+  }
+  set undefinedValue(t) {
+    this._undefinedValue = t, this.isUndefined = g[t] || g.UndefinedAndNull;
+  }
+  _undefinedValue = "UndefinedAndNull";
+  /**
+   * 未定义值的判断函数
+   */
+  isUndefined = g.UndefinedAndNull;
+  /**
+   * 获取选项成员
+   * @param key 
+   * @returns 
+   */
+  getMember(t) {
+    return this.option[t];
+  }
+  /**
+   * 设置选项成员
+   * @param key 
+   * @param value 
+   * @param deep - 是否要进行深度合并 
+   */
+  setMember(t, e, n) {
+    const s = this.option;
+    if (e === void 0)
+      delete s[t];
+    else {
+      const o = s[t];
+      n && o && typeof o == "object" ? c(o, e) : s[t] = e;
+    }
+    this.updateFullOption();
+  }
+  /**
+   * 获取属性路径对应的值
+   * @param propPath 
+   * @returns 
+   */
+  getValue(t) {
+    return f(this.option, t);
+  }
+  /**
+   * 设置属性路径对应的值
+   * @param propPath 
+   * @param value
+   * @param deep - 是否要进行深度合并 
+   * @returns 
+   */
+  setValue(t, e, n) {
+    const s = this.option;
+    let o;
+    n && (o = f(s, t)) && typeof o == "object" ? c(o, e) : P(this.option, t, e), this.updateFullOption();
+  }
+}
+class u extends _ {
+  constructor(t, e) {
+    super(), t && (this.option = t), e && (this.extends = e);
+  }
+  /**
+   * 继承的选项
+   */
+  get extends() {
+    return this._extends;
+  }
+  set extends(t) {
+    this._extends = t, this.updateFullOption();
+  }
+  _extends = null;
+  /**
+   * 选项
+   */
+  option = {};
+  /**
+   * 获取完整的选项
+   * @remarks
+   * 会与继承来的选项进行合并
+   */
+  get plainFullOption() {
+    let t = this._plainFullOption;
+    if (t) return t;
+    const { extends: e, option: n } = this;
+    if (t = n, e) {
+      const s = e.plainFullOption;
+      t = M(s, n);
+    }
+    return this._plainFullOption = t;
+  }
+  _plainFullOption = null;
+  /**
+   * 更新
+   */
+  updateFullOption() {
+    this._plainFullOption = null;
+  }
+  /**
+   * 获取选项成员
+   * @param key 
+   * @returns 
+   */
+  getMember(t) {
+    const e = this.option[t];
+    if (!this.isUndefined(e)) return e;
+    const n = this.extends;
+    if (n)
+      return n.getMember(t);
+  }
+  /**
+   * 获取属性路径对应的值
+   * @param propPath 
+   * @returns 
+   */
+  getValue(t) {
+    const e = super.getValue(t);
+    if (!this.isUndefined(e)) return e;
+    const n = this.extends;
+    if (n)
+      return n.getValue(t);
+  }
+}
+function C(i, t) {
+  const { name: e } = t, n = `_${e}`;
+  return {
+    get: function() {
+      return this[n] || (this[n] = new u(void 0, this.constructor[e]));
+    }
+  };
+}
+class T extends _ {
+  constructor(t, e) {
+    super(), e && this.setModeOption(t, e), this.mode = t;
+  }
+  /**
+   * 模式的配置
+   */
+  modes = {};
+  /**
+   * 当前模式
+   */
+  get mode() {
+    return this._mode || (this.mode = this.modeNames[0]);
+  }
+  set mode(t) {
+    this._mode = t, this.hasMode(t) || this.setModeOption(t, {}), this.updateFullOption();
+  }
+  _mode;
+  /**
+   * 所有的模式名字
+   */
+  get modeNames() {
+    return this._modeNames || (this._modeNames = this.getModeNames());
+  }
+  _modeNames = null;
+  /**
+   * 获取所有的模式名字
+   * @returns 
+   */
+  getModeNames() {
+    return Object.keys(this.modes);
+  }
+  /**
+   * 判断是否有某个模式
+   * @param mode 
+   * @returns 
+   */
+  hasMode(t) {
+    return !!this.modes[t];
+  }
+  /**
+   * 当前模式的选项
+   */
+  get optionManager() {
+    return this.modes[this.mode];
+  }
+  /**
+   * 当前模式对应的选项
+   */
+  get option() {
+    return this.optionManager.option;
+  }
+  get plainFullOption() {
+    return this._plainFullOption ?? (this._plainFullOption = this.getFullModeOption(this.mode));
+  }
+  _plainFullOption = null;
+  /**
+   * 更新
+   */
+  updateFullOption() {
+    this._plainFullOption = null, this._modeNames = null;
+  }
+  /**
+   * 返回已合并继承选项的选项
+   * @remarks
+   * 与继承选项只是浅合并
+   * @param mode 
+   * @returns 
+   */
+  getModeOption(t) {
+    return this.modes[t].option;
+  }
+  /**
+   * 返回已合并继承选项的完整选项
+   * @remarks
+   * 与继承选项合并
+   * @param mode 
+   * @returns 
+   */
+  getFullModeOption(t) {
+    return this.modes[t]?.plainFullOption;
+  }
+  /**
+   * 给模式设置选项
+   * @param mode 
+   * @param option 
+   * @param deep - 是否要进行深度合并 
+   * @param extend - 继承哪个模式
+   */
+  setModeOption(t, e, n, s) {
+    const { modes: o } = this, r = o[t] || (o[t] = new u());
+    if (r.setOption(e, n), s) {
+      const O = o[s];
+      O && (r.extends = O);
+    }
+    return this.updateFullOption(), r;
+  }
+}
+class l extends T {
+  constructor(t, e, n) {
+    super(t, e), n && (this.extends = n);
+  }
+  /**
+   * 继承的选项
+   */
+  get extends() {
+    return this._extends;
+  }
+  set extends(t) {
+    this._extends = t, this.updateFullOption();
+  }
+  _extends = null;
+  /**
+   * 返回已合并继承选项的最终选项
+   * @remarks
+   * 与继承选项只是浅合并
+   * @param mode 
+   * @returns 
+   */
+  getFullModeOption(t) {
+    const { modes: e, extends: n } = this, s = e[t]?.plainFullOption;
+    if (n) {
+      const o = n.getFullModeOption(t);
+      return s ? M(o, s) : o;
+    }
+    return s;
+  }
+  /**
+   * 获取所有的模式名字
+   * @returns 
+   */
+  getModeNames() {
+    const { modes: t, extends: e } = this, n = Object.keys(t);
+    if (!e) return n;
+    const s = e.getModeNames();
+    return [.../* @__PURE__ */ new Set([...n, ...s])];
+  }
+  /**
+   * 在整个层级上判断是否有某个模式
+   * @param mode 
+   * @returns 
+   */
+  hasModeOnTier(t) {
+    if (this.hasMode(t)) return !0;
+    const e = this.extends;
+    return e ? e.hasModeOnTier(t) : !1;
+  }
+  /**
+   * 当前模式的选项
+   */
+  get optionManager() {
+    return this.getModeOptionManager(this.mode);
+  }
+  /**
+   * 获取模式对应的选项管理器
+   * @param mode 
+   * @returns 
+   */
+  getModeOptionManager(t) {
+    const e = this.modes[t];
+    return e || (this.extends?.getModeOptionManager(t) ? this.setModeOption(t, {}) : null);
+  }
+  /**
+   * 获取选项成员
+   * @param key 
+   * @returns 
+   */
+  getMember(t) {
+    const e = this.optionManager.getMember(t);
+    if (!this.isUndefined(e)) return e;
+    const n = this.extends;
+    if (n)
+      return n.getMember(t);
+  }
+  /**
+   * 获取属性路径对应的值
+   * @param propPath 
+   * @returns 
+   */
+  getValue(t) {
+    const e = this.optionManager.getValue(t);
+    if (!this.isUndefined(e)) return e;
+    const n = this.extends;
+    if (n)
+      return n.getValue(t);
+  }
+}
+function S(i, t) {
+  const { name: e } = t, n = `_${e}`;
+  return {
+    get: function() {
+      return this[n] || (this[n] = new l(this.constructor[e].mode, void 0, this.constructor[e]));
+    }
+  };
+}
+class F extends m {
+  /**
+   * 是否使用独立的插件管理器
+   * @defaultValue false
+   */
+  static isolatedPluginManager = !1;
+  /**
+   * 插件管理器
+   */
+  static get pluginManager() {
+    return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new d(this)), this._pluginManager;
+  }
+  static _pluginManager = new d(this);
+  /**
+   * 插件管理器 {@link PluginHost.pluginManager}
+   */
+  get pluginManager() {
+    return this.constructor.pluginManager;
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.usePlugin}
+   */
+  static usePlugin(t, ...e) {
+    return this.pluginManager.usePlugin(t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  static useExtend(t) {
+    return this.pluginManager.useExtend(t);
+  }
+  /**
+   * 是否注册了插件 或 扩展
+   * @param plugin - 插件 或 扩展
+   * @returns 是否注册了插件 或 扩展
+   */
+  static hasUsed(t) {
+    return this.pluginManager.hasUsed(t);
+  }
+  /**
+   * 需要在子类中调用
+   * 
+   * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this,...args)` 通常会在构建函数执行的最后时才调用；
+   * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this,...args)` 不是在最后的执行； 
+   */
+  // constructor(...args:any) {
+  //   super();
+  //   // @ts-ignore
+  //   this.pluginManager.onCreate(this,...args);
+  // }
+  /**
+   * 实例的注册插件的方法
+   * @param plugin
+   * @param args
+   * @returns
+   */
+  usePlugin(t, ...e) {
+    return this.pluginManager.instUsePlugin(this, t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  useExtend(t, ...e) {
+    return this.pluginManager.instUseExtend(this, t, ...e);
+  }
+  /**
+   * 初始化实例
+   * @remarks
+   * 会调用 {@link PluginExtendManager.onInit}
+   * @param args 
+   */
+  init(...t) {
+    return this.pluginManager.onInit(this, ...t);
+  }
+  /**
+   * 销毁实例
+   * @returns 
+   */
+  destroyThis() {
+    const t = this.pluginManager.onDestroy(this);
+    return t instanceof Promise ? t.finally(() => super.destroyThis()) : super.destroyThis();
+  }
+}
+class I extends F {
+  /**
+   * 全局级别的默认选项
+   */
+  static defaultOptions = new u();
+  /**
+   * 实例级的默认选项
+   */
+  get defaultOptions() {
+    return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
+  }
+  _defaultOptions;
+  constructor(t) {
+    super(), this.defaultOptions.option = t;
+  }
+}
+function b(i) {
+  const t = U(i);
+  return class extends t {
+    /**
+     * 是否使用独立的插件管理器
+     * @defaultValue false
+     */
+    static isolatedPluginManager = !1;
+    /**
+     * 插件管理器
+     */
+    static get pluginManager() {
+      return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new d(this)), this._pluginManager;
+    }
+    static _pluginManager = new d(this);
+    /**
+     * 插件管理器 {@link PluginHostSub.pluginManager}
+     */
+    get pluginManager() {
+      return this.constructor.pluginManager;
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.usePlugin}
+     */
+    static usePlugin(n, ...s) {
+      return this.pluginManager.usePlugin(n, ...s);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    static useExtend(n) {
+      return this.pluginManager.useExtend(n);
+    }
+    /**
+     * 是否注册了插件 或 扩展
+     * @param plugin - 插件 或 扩展
+     * @returns 是否注册了插件 或 扩展
+     */
+    static hasUsed(n) {
+      return this.pluginManager.hasUsed(n);
+    }
+    /**
+     * 需要在子类中调用
+     * 
+     * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this)` 通常会在构建函数执行的最后时才调用；
+     * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this)` 不是在最后的执行；
+     */
+    // constructor() {
+    //   super();
+    //   this.pluginManager.onCreate(this);
+    // }
+    /**
+     * 实例的注册插件的方法
+     * @param plugin
+     * @param args
+     * @returns
+     */
+    usePlugin(n, ...s) {
+      return this.pluginManager.instUsePlugin(this, n, ...s);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    useExtend(n, ...s) {
+      return this.pluginManager.instUseExtend(this, n, ...s);
+    }
+    /**
+     * 初始化实例
+     * @remarks
+     * 会调用 {@link PluginExtendManager.onInit}
+     * @param args 
+     */
+    init(...n) {
+      return this.pluginManager.onInit(this, ...n);
+    }
+    /**
+     * 销毁实例
+     * @returns 
+     */
+    destroyThis() {
+      const n = this.pluginManager.onDestroy(this);
+      return n instanceof Promise ? n.finally(() => super.destroyThis()) : super.destroyThis();
+    }
+  };
+}
+function z(i) {
+  const t = b(i);
+  return class extends t {
+    /**
+     * 全局级别的默认选项
+     */
+    static defaultOptions = new u();
+    /**
+     * 实例级的默认选项
+     */
+    get defaultOptions() {
+      return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
+    }
+    _defaultOptions;
+    constructor(n) {
+      super(), this.defaultOptions.option = n;
+    }
+  };
+}
+const p = "common";
+class K extends F {
+  /**
+   * 全局级别的默认选项
+   */
+  static modeOptions = new l(p);
+  /**
+   * 实例级的默认选项
+   */
+  get modeOptions() {
+    return this._modeOptions || (this._modeOptions = new l(p, void 0, this.constructor.modeOptions));
+  }
+  _modeOptions;
+  get mode() {
+    return this.modeOptions.mode;
+  }
+  set mode(t) {
+    this.modeOptions.mode = t;
+  }
+  get options() {
+    return this.modeOptions.plainFullOption;
+  }
+  constructor(t) {
+    super(), this.modeOptions.setOption(t);
+  }
+}
+function $(i) {
+  const t = b(i);
+  return class extends t {
+    /**
+     * 全局级别的默认选项
+     */
+    static modeOptions = new l(p);
+    /**
+     * 实例级的默认选项
+     */
+    get modeOptions() {
+      return this._modeOptions || (this._modeOptions = new l(p, void 0, this.constructor.modeOptions));
+    }
+    _modeOptions;
+    get mode() {
+      return this.modeOptions.mode;
+    }
+    set mode(n) {
+      this.modeOptions.mode = n;
+    }
+    get options() {
+      return this.modeOptions.plainFullOption;
+    }
+    constructor(n) {
+      super(), this.modeOptions.setOption(n);
+    }
+  };
+}
+export {
+  T as M,
+  d as P,
+  l as T,
+  u as a,
+  F as b,
+  p as c,
+  K as d,
+  I as e,
+  b as f,
+  $ as g,
+  z as h,
+  a as i,
+  f as j,
+  k,
+  N as l,
+  w as m,
+  E as n,
+  H as o,
+  y as p,
+  C as q,
+  P as s,
+  S as t
+};