@ynput/ayon-frontend-shared 0.3.54 → 0.3.56

package/dist/shared/node_modules/@module-federation/runtime-core/dist/shared/index.es.js

@@ -1,340 +1,250 @@
-import { warn as E, assert as H, error as v } from "../utils/logger.es.js";
-import { DEFAULT_SCOPE as U } from "../constant.es.js";
-import { formatShareConfigs as _, getTargetSharedOptions as I, getRegisteredShare as L, directShare as M, addUseIn as u, shouldUseTreeShaking as k, getGlobalShareScope as z } from "../utils/share.es.js";
-import { optionsToMFContext as A } from "../utils/context.es.js";
-import "../global.es.js";
-import { RUNTIME_005 as G, RUNTIME_006 as T } from "../../../error-codes/dist/error-codes.es.js";
-import { runtimeDescMap as P } from "../../../error-codes/dist/desc.es.js";
-import { SyncHook as R } from "../utils/hooks/syncHook.es.js";
-import { AsyncHook as O } from "../utils/hooks/asyncHook.es.js";
-import { SyncWaterfallHook as w } from "../utils/hooks/syncWaterfallHook.es.js";
-import { AsyncWaterfallHook as C } from "../utils/hooks/asyncWaterfallHooks.es.js";
-import { PluginSystem as $ } from "../utils/hooks/pluginSystem.es.js";
-var K = class {
-  constructor(e) {
-    this.hooks = new $({
-      beforeRegisterShare: new w("beforeRegisterShare"),
-      afterResolve: new C("afterResolve"),
-      beforeLoadShare: new C("beforeLoadShare"),
-      loadShare: new O(),
-      afterLoadShare: new R("afterLoadShare"),
-      errorLoadShare: new R("errorLoadShare"),
-      resolveShare: new w("resolveShare"),
-      initContainerShareScopeMap: new w("initContainerShareScopeMap")
-    }), this.host = e, this.shareScopeMap = {}, this.initTokens = {}, this._setGlobalShareScopeMap(e.options);
-  }
-  emitAfterLoadShare({ lifecycle: e, pkgName: n, shareInfo: o, selectedShared: r }) {
-    try {
-      this.hooks.lifecycle.afterLoadShare.emit({
-        pkgName: n,
-        shareInfo: o,
-        selectedShared: r,
-        shared: this.host.options.shared,
-        shareScopeMap: this.shareScopeMap,
-        lifecycle: e,
-        origin: this.host
-      });
-    } catch (i) {
-      E(i);
-    }
-  }
-  emitErrorLoadShare({ lifecycle: e, pkgName: n, shareInfo: o, error: r, recovered: i }) {
-    try {
-      this.hooks.lifecycle.errorLoadShare.emit({
-        pkgName: n,
-        shareInfo: o,
-        shared: this.host.options.shared,
-        shareScopeMap: this.shareScopeMap,
-        lifecycle: e,
-        origin: this.host,
-        error: r,
-        recovered: i
-      });
-    } catch (t) {
-      E(t);
+import { __exports as k } from "../../../../../../_virtual/index.es18.js";
+import { __require as P } from "../utils/logger.es.js";
+import { __require as U } from "../constant.es.js";
+import { __require as C } from "../utils/share.es.js";
+import { __require as L } from "../utils/context.es.js";
+import { __require as A } from "../utils/index.es.js";
+import { __require as W } from "../utils/hooks/asyncHook.es.js";
+import { __require as x } from "../utils/hooks/syncWaterfallHook.es.js";
+import { __require as z } from "../utils/hooks/asyncWaterfallHooks.es.js";
+import { __require as D } from "../utils/hooks/pluginSystem.es.js";
+import { __require as G } from "../utils/hooks/index.es.js";
+import { __require as O } from "../../../error-codes/dist/index.es.js";
+var w;
+function ee() {
+  if (w) return k;
+  w = 1;
+  const q = P(), H = U(), l = C(), v = L();
+  A();
+  const I = W(), M = x(), E = z(), T = D();
+  G();
+  let _ = /* @__PURE__ */ O();
+  var R = class {
+    constructor(o) {
+      this.hooks = new T.PluginSystem({
+        beforeRegisterShare: new M.SyncWaterfallHook("beforeRegisterShare"),
+        afterResolve: new E.AsyncWaterfallHook("afterResolve"),
+        beforeLoadShare: new E.AsyncWaterfallHook("beforeLoadShare"),
+        loadShare: new I.AsyncHook(),
+        resolveShare: new M.SyncWaterfallHook("resolveShare"),
+        initContainerShareScopeMap: new M.SyncWaterfallHook("initContainerShareScopeMap")
+      }), this.host = o, this.shareScopeMap = {}, this.initTokens = {}, this._setGlobalShareScopeMap(o.options);
     }
-  }
-  registerShared(e, n) {
-    const { newShareInfos: o, allShareInfos: r } = _(e, n);
-    return Object.keys(o).forEach((i) => {
-      o[i].forEach((t) => {
-        t.scope.forEach((l) => {
-          this.hooks.lifecycle.beforeRegisterShare.emit({
-            origin: this.host,
-            pkgName: i,
-            shared: t
-          }), this.shareScopeMap[l]?.[i] || this.setShared({
-            pkgName: i,
-            lib: t.lib,
-            get: t.get,
-            loaded: t.loaded || !!t.lib,
-            shared: t,
-            from: n.name
+    registerShared(o, h) {
+      const { newShareInfos: e, allShareInfos: r } = l.formatShareConfigs(o, h);
+      return Object.keys(e).forEach((i) => {
+        e[i].forEach((c) => {
+          c.scope.forEach((d) => {
+            this.hooks.lifecycle.beforeRegisterShare.emit({
+              origin: this.host,
+              pkgName: i,
+              shared: c
+            }), this.shareScopeMap[d]?.[i] || this.setShared({
+              pkgName: i,
+              lib: c.lib,
+              get: c.get,
+              loaded: c.loaded || !!c.lib,
+              shared: c,
+              from: h.name
+            });
           });
         });
+      }), {
+        newShareInfos: e,
+        allShareInfos: r
+      };
+    }
+    async loadShare(o, h) {
+      const { host: e } = this, r = l.getTargetSharedOptions({
+        pkgName: o,
+        extraOptions: h,
+        shareInfos: e.options.shared
       });
-    }), {
-      newShareInfos: o,
-      allShareInfos: r
-    };
-  }
-  async loadShare(e, n) {
-    const { host: o } = this, r = I({
-      pkgName: e,
-      extraOptions: n,
-      shareInfos: o.options.shared
-    });
-    let i = r;
-    try {
       r?.scope && await Promise.all(r.scope.map(async (s) => {
         await Promise.all(this.initializeSharing(s, { strategy: r.strategy }));
-      })), i = (await this.hooks.lifecycle.beforeLoadShare.emit({
-        pkgName: e,
+      }));
+      const { shareInfo: i } = await this.hooks.lifecycle.beforeLoadShare.emit({
+        pkgName: o,
         shareInfo: r,
-        shared: o.options.shared,
-        origin: o
-      })).shareInfo, H(i, `Cannot find shared "${e}" in host "${o.options.name}". Ensure the shared config for "${e}" is declared in the federation plugin options and the host has been initialized before loading shares.`);
-      const t = i, { shared: l, useTreesShaking: m } = L(this.shareScopeMap, e, i, this.hooks.lifecycle.resolveShare) || {};
-      if (l) {
-        const s = M(l, m);
+        shared: e.options.shared,
+        origin: e
+      });
+      q.assert(i, `Cannot find shared "${o}" in host "${e.options.name}". Ensure the shared config for "${o}" is declared in the federation plugin options and the host has been initialized before loading shares.`);
+      const { shared: c, useTreesShaking: d } = l.getRegisteredShare(this.shareScopeMap, o, i, this.hooks.lifecycle.resolveShare) || {};
+      if (c) {
+        const s = l.directShare(c, d);
         if (s.lib)
-          return u(s, o.options.name), this.emitAfterLoadShare({
-            lifecycle: "loadShare",
-            pkgName: e,
-            shareInfo: t,
-            selectedShared: l
-          }), s.lib;
+          return l.addUseIn(s, e.options.name), s.lib;
         if (s.loading && !s.loaded) {
-          const d = await s.loading;
-          return s.loaded = !0, s.lib || (s.lib = d), u(s, o.options.name), this.emitAfterLoadShare({
-            lifecycle: "loadShare",
-            pkgName: e,
-            shareInfo: t,
-            selectedShared: l
-          }), d;
+          const f = await s.loading;
+          return s.loaded = !0, s.lib || (s.lib = f), l.addUseIn(s, e.options.name), f;
         } else {
-          const g = (async () => {
-            const h = await s.get();
-            return u(s, o.options.name), s.loaded = !0, s.lib = h, h;
+          const S = (async () => {
+            const u = await s.get();
+            return l.addUseIn(s, e.options.name), s.loaded = !0, s.lib = u, u;
           })();
-          this.setShared({
-            pkgName: e,
+          return this.setShared({
+            pkgName: o,
             loaded: !1,
-            shared: l,
-            from: o.options.name,
+            shared: c,
+            from: e.options.name,
             lib: null,
-            loading: g,
-            treeShaking: m ? s : void 0
-          });
-          const y = await g;
-          return this.emitAfterLoadShare({
-            lifecycle: "loadShare",
-            pkgName: e,
-            shareInfo: t,
-            selectedShared: l
-          }), y;
+            loading: S,
+            treeShaking: d ? s : void 0
+          }), S;
         }
       } else {
-        if (n?.customShareInfo)
-          return this.emitErrorLoadShare({
-            lifecycle: "loadShare",
-            pkgName: e,
-            shareInfo: t,
-            recovered: !0
-          }), !1;
-        const s = k(t.treeShaking), d = M(t, s), y = (async () => {
-          const a = await d.get();
-          d.lib = a, d.loaded = !0, u(d, o.options.name);
-          const { shared: c, useTreesShaking: S } = L(this.shareScopeMap, e, t, this.hooks.lifecycle.resolveShare) || {};
-          if (c) {
-            const p = M(c, S);
-            p.lib = a, p.loaded = !0, c.from = t.from;
+        if (h?.customShareInfo) return !1;
+        const s = l.shouldUseTreeShaking(i.treeShaking), f = l.directShare(i, s), u = (async () => {
+          const m = await f.get();
+          f.lib = m, f.loaded = !0, l.addUseIn(f, e.options.name);
+          const { shared: a, useTreesShaking: t } = l.getRegisteredShare(this.shareScopeMap, o, i, this.hooks.lifecycle.resolveShare) || {};
+          if (a) {
+            const n = l.directShare(a, t);
+            n.lib = m, n.loaded = !0, a.from = i.from;
           }
-          return a;
+          return m;
         })();
-        this.setShared({
-          pkgName: e,
+        return this.setShared({
+          pkgName: o,
           loaded: !1,
-          shared: t,
-          from: o.options.name,
+          shared: i,
+          from: e.options.name,
           lib: null,
-          loading: y,
-          treeShaking: s ? d : void 0
-        });
-        const h = await y;
-        return this.emitAfterLoadShare({
-          lifecycle: "loadShare",
-          pkgName: e,
-          shareInfo: t,
-          selectedShared: t
-        }), h;
+          loading: u,
+          treeShaking: s ? f : void 0
+        }), u;
       }
-    } catch (t) {
-      throw this.emitErrorLoadShare({
-        lifecycle: "loadShare",
-        pkgName: e,
-        shareInfo: i,
-        error: t
-      }), t;
-    }
-  }
-  /**
-  * This function initializes the sharing sequence (executed only once per share scope).
-  * It accepts one argument, the name of the share scope.
-  * If the share scope does not exist, it creates one.
-  */
-  initializeSharing(e = U, n) {
-    const { host: o } = this, r = n?.from, i = n?.strategy;
-    let t = n?.initScope;
-    const l = [];
-    if (r !== "build") {
-      const { initTokens: h } = this;
-      t || (t = []);
-      let a = h[e];
-      if (a || (a = h[e] = { from: this.host.name }), t.indexOf(a) >= 0) return l;
-      t.push(a);
     }
-    const m = this.shareScopeMap, s = o.options.name;
-    m[e] || (m[e] = {});
-    const d = m[e], g = (h, a) => {
-      const { version: c, eager: S } = a;
-      d[h] = d[h] || {};
-      const p = d[h], f = p[c] && M(p[c]), b = !!(f && ("eager" in f && f.eager || "shareConfig" in f && f.shareConfig?.eager));
-      (!f || f.strategy !== "loaded-first" && !f.loaded && (!S != !b ? S : s > p[c].from)) && (p[c] = a);
-    }, y = async (h) => {
-      const { module: a } = await o.remoteHandler.getRemoteModuleAndOptions({ id: h });
-      let c;
-      try {
-        c = await a.getEntry();
-      } catch (S) {
-        if (c = await o.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-          id: h,
-          error: S,
-          from: "runtime",
-          lifecycle: "beforeLoadShare",
-          remote: a.remoteInfo,
-          origin: o
-        }), !c) return;
-      } finally {
-        c?.init && !a.initing && (a.remoteEntryExports = c, await a.init(void 0, void 0, t));
+    /**
+    * This function initializes the sharing sequence (executed only once per share scope).
+    * It accepts one argument, the name of the share scope.
+    * If the share scope does not exist, it creates one.
+    */
+    initializeSharing(o = H.DEFAULT_SCOPE, h) {
+      const { host: e } = this, r = h?.from, i = h?.strategy;
+      let c = h?.initScope;
+      const d = [];
+      if (r !== "build") {
+        const { initTokens: a } = this;
+        c || (c = []);
+        let t = a[o];
+        if (t || (t = a[o] = { from: this.host.name }), c.indexOf(t) >= 0) return d;
+        c.push(t);
       }
-    };
-    return Object.keys(o.options.shared).forEach((h) => {
-      o.options.shared[h].forEach((a) => {
-        a.scope.includes(e) && g(h, a);
+      const s = this.shareScopeMap, f = e.options.name;
+      s[o] || (s[o] = {});
+      const S = s[o], u = (a, t) => {
+        const { version: n, eager: g } = t;
+        S[a] = S[a] || {};
+        const y = S[a], p = y[n] && l.directShare(y[n]), b = !!(p && ("eager" in p && p.eager || "shareConfig" in p && p.shareConfig?.eager));
+        (!p || p.strategy !== "loaded-first" && !p.loaded && (!g != !b ? g : f > y[n].from)) && (y[n] = t);
+      }, m = async (a) => {
+        const { module: t } = await e.remoteHandler.getRemoteModuleAndOptions({ id: a });
+        let n;
+        try {
+          n = await t.getEntry();
+        } catch (g) {
+          if (n = await e.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+            id: a,
+            error: g,
+            from: "runtime",
+            lifecycle: "beforeLoadShare",
+            origin: e
+          }), !n) return;
+        } finally {
+          n?.init && !t.initing && (t.remoteEntryExports = n, await t.init(void 0, void 0, c));
+        }
+      };
+      return Object.keys(e.options.shared).forEach((a) => {
+        e.options.shared[a].forEach((t) => {
+          t.scope.includes(o) && u(a, t);
+        });
+      }), (e.options.shareStrategy === "version-first" || i === "version-first") && e.options.remotes.forEach((a) => {
+        a.shareScope === o && d.push(m(a.name));
+      }), d;
+    }
+    loadShareSync(o, h) {
+      const { host: e } = this, r = l.getTargetSharedOptions({
+        pkgName: o,
+        extraOptions: h,
+        shareInfos: e.options.shared
       });
-    }), (o.options.shareStrategy === "version-first" || i === "version-first") && o.options.remotes.forEach((h) => {
-      h.shareScope === e && l.push(y(h.name));
-    }), l;
-  }
-  loadShareSync(e, n) {
-    const { host: o } = this, r = I({
-      pkgName: e,
-      extraOptions: n,
-      shareInfos: o.options.shared
-    });
-    try {
-      r?.scope && r.scope.forEach((t) => {
-        this.initializeSharing(t, { strategy: r.strategy });
+      r?.scope && r.scope.forEach((d) => {
+        this.initializeSharing(d, { strategy: r.strategy });
       });
-      const { shared: i } = L(this.shareScopeMap, e, r, this.hooks.lifecycle.resolveShare) || {};
+      const { shared: i, useTreesShaking: c } = l.getRegisteredShare(this.shareScopeMap, o, r, this.hooks.lifecycle.resolveShare) || {};
       if (i) {
         if (typeof i.lib == "function")
-          return u(i, o.options.name), i.loaded || (i.loaded = !0, i.from === o.options.name && (r.loaded = !0)), this.emitAfterLoadShare({
-            lifecycle: "loadShareSync",
-            pkgName: e,
-            shareInfo: r,
-            selectedShared: i
-          }), i.lib;
+          return l.addUseIn(i, e.options.name), i.loaded || (i.loaded = !0, i.from === e.options.name && (r.loaded = !0)), i.lib;
         if (typeof i.get == "function") {
-          const t = i.get();
-          if (!(t instanceof Promise))
-            return u(i, o.options.name), this.setShared({
-              pkgName: e,
+          const d = i.get();
+          if (!(d instanceof Promise))
+            return l.addUseIn(i, e.options.name), this.setShared({
+              pkgName: o,
               loaded: !0,
-              from: o.options.name,
-              lib: t,
+              from: e.options.name,
+              lib: d,
               shared: i
-            }), this.emitAfterLoadShare({
-              lifecycle: "loadShareSync",
-              pkgName: e,
-              shareInfo: r,
-              selectedShared: i
-            }), t;
+            }), d;
         }
       }
       if (r.lib)
-        return r.loaded || (r.loaded = !0), this.emitAfterLoadShare({
-          lifecycle: "loadShareSync",
-          pkgName: e,
-          shareInfo: r,
-          selectedShared: r
-        }), r.lib;
+        return r.loaded || (r.loaded = !0), r.lib;
       if (r.get) {
-        const t = r.get();
-        return t instanceof Promise && v(n?.from === "build" ? G : T, P, {
-          hostName: o.options.name,
-          sharedPkgName: e
-        }, void 0, A(o.options)), r.lib = t, this.setShared({
-          pkgName: e,
+        const d = r.get();
+        return d instanceof Promise && q.error(h?.from === "build" ? _.RUNTIME_005 : _.RUNTIME_006, _.runtimeDescMap, {
+          hostName: e.options.name,
+          sharedPkgName: o
+        }, void 0, v.optionsToMFContext(e.options)), r.lib = d, this.setShared({
+          pkgName: o,
           loaded: !0,
-          from: o.options.name,
+          from: e.options.name,
           lib: r.lib,
           shared: r
-        }), this.emitAfterLoadShare({
-          lifecycle: "loadShareSync",
-          pkgName: e,
-          shareInfo: r,
-          selectedShared: r
         }), r.lib;
       }
-      v(T, P, {
-        hostName: o.options.name,
-        sharedPkgName: e
-      }, void 0, A(o.options));
-    } catch (i) {
-      throw this.emitErrorLoadShare({
-        lifecycle: "loadShareSync",
-        pkgName: e,
-        shareInfo: r,
-        error: i
-      }), i;
+      q.error(_.RUNTIME_006, _.runtimeDescMap, {
+        hostName: e.options.name,
+        sharedPkgName: o
+      }, void 0, v.optionsToMFContext(e.options));
     }
-  }
-  initShareScopeMap(e, n, o = {}) {
-    const { host: r } = this;
-    this.shareScopeMap[e] = n, this.hooks.lifecycle.initContainerShareScopeMap.emit({
-      shareScope: n,
-      options: r.options,
-      origin: r,
-      scopeName: e,
-      hostShareScopeMap: o.hostShareScopeMap
-    });
-  }
-  setShared({ pkgName: e, shared: n, from: o, lib: r, loading: i, loaded: t, get: l, treeShaking: m }) {
-    const { version: s, scope: d = "default", ...g } = n, y = Array.isArray(d) ? d : [d], h = (a) => {
-      const c = (p, f, b) => {
-        b && !p[f] && (p[f] = b);
-      }, S = m ? a.treeShaking : a;
-      c(S, "loaded", t), c(S, "loading", i), c(S, "get", l);
-    };
-    y.forEach((a) => {
-      this.shareScopeMap[a] || (this.shareScopeMap[a] = {}), this.shareScopeMap[a][e] || (this.shareScopeMap[a][e] = {}), this.shareScopeMap[a][e][s] || (this.shareScopeMap[a][e][s] = {
-        version: s,
-        scope: [a],
-        ...g,
-        lib: r
+    initShareScopeMap(o, h, e = {}) {
+      const { host: r } = this;
+      this.shareScopeMap[o] = h, this.hooks.lifecycle.initContainerShareScopeMap.emit({
+        shareScope: h,
+        options: r.options,
+        origin: r,
+        scopeName: o,
+        hostShareScopeMap: e.hostShareScopeMap
       });
-      const c = this.shareScopeMap[a][e][s];
-      h(c), o && c.from !== o && (c.from = o);
-    });
-  }
-  _setGlobalShareScopeMap(e) {
-    const n = z(), o = e.id || e.name;
-    o && !n[o] && (n[o] = this.shareScopeMap);
-  }
-};
+    }
+    setShared({ pkgName: o, shared: h, from: e, lib: r, loading: i, loaded: c, get: d, treeShaking: s }) {
+      const { version: f, scope: S = "default", ...u } = h, m = Array.isArray(S) ? S : [S], a = (t) => {
+        const n = (y, p, b) => {
+          b && !y[p] && (y[p] = b);
+        }, g = s ? t.treeShaking : t;
+        n(g, "loaded", c), n(g, "loading", i), n(g, "get", d);
+      };
+      m.forEach((t) => {
+        this.shareScopeMap[t] || (this.shareScopeMap[t] = {}), this.shareScopeMap[t][o] || (this.shareScopeMap[t][o] = {}), this.shareScopeMap[t][o][f] || (this.shareScopeMap[t][o][f] = {
+          version: f,
+          scope: [t],
+          ...u,
+          lib: r
+        });
+        const n = this.shareScopeMap[t][o][f];
+        a(n), e && n.from !== e && (n.from = e);
+      });
+    }
+    _setGlobalShareScopeMap(o) {
+      const h = l.getGlobalShareScope(), e = o.id || o.name;
+      e && !h[e] && (h[e] = this.shareScopeMap);
+    }
+  };
+  return k.SharedHandler = R, k;
+}
 export {
-  K as SharedHandler
+  ee as __require
 };
 //# sourceMappingURL=index.es.js.map