vue-fn 0.1.0-beta.0 → 0.1.0-beta.2

package/domain/index.mjs

@@ -1,199 +1,209 @@
-import { ref as b, computed as m, shallowRef as P, shallowReactive as S, watch as E, readonly as w, triggerRef as C, effectScope as F, onScopeDispose as M, shallowReadonly as y } from "vue";
+import { ref as E, computed as m, shallowRef as P, shallowReactive as S, watch as b, readonly as I, triggerRef as C, effectScope as M, onScopeDispose as F, shallowReadonly as y } from "vue";
 import { n as T } from "../index.browser-CWCjzKuA.js";
-function I(r, o = !0, a = !1) {
-  const n = b();
-  let e;
-  const t = b(!1);
-  let i = () => {
+function g(s, i = !0, u = !1) {
+  const c = E();
+  let t;
+  const r = E(!1);
+  let e = () => {
   };
-  const u = new Proxy(r, {
-    apply: function(c, d, s) {
-      let l;
+  const n = new Proxy(s, {
+    apply: function(l, f, a) {
+      let d;
       try {
-        l = c(...s);
+        d = l(...a);
       } catch (p) {
-        l = p;
+        d = p;
       }
-      if (l instanceof Error) {
-        if (n.value = l, e = l, o)
-          throw i(), l;
+      if (d instanceof Error) {
+        if (c.value = d, t = d, i)
+          throw e(), d;
       } else
-        t.value = !0, n.value = void 0, e = !0, i();
+        r.value = !0, c.value = void 0, t = !0, e();
     }
-  }), f = () => {
+  }), o = () => {
   }, v = new Proxy(
-    (c) => {
-      n.value = c;
+    (l) => {
+      c.value = l;
     },
     {
-      apply: function(c, d, s) {
-        c(...s), f(...s);
+      apply: function(l, f, a) {
+        l(...a), o(...a);
       }
     }
   );
   return {
-    promise: new Promise((c, d) => {
-      if (o && e instanceof Error) {
-        d(e);
+    promise: new Promise((l, f) => {
+      if (i && t instanceof Error) {
+        f(t);
         return;
-      } else if (e === !0) {
-        c();
+      } else if (t === !0) {
+        l();
         return;
       }
-      let s;
-      a && (s = setTimeout(() => {
-        const l = new Error("timeout!");
-        n.value = l, o && d(l);
-      }, a)), i = () => {
-        s && (clearTimeout(s), s = void 0), c();
+      let a;
+      u && (a = setTimeout(() => {
+        const d = new Error("timeout!");
+        c.value = d, i && f(d);
+      }, u)), e = () => {
+        a && (clearTimeout(a), a = void 0), l();
       };
     }),
-    callback: u,
+    callback: n,
     onError: v,
-    resolved: m(() => t.value),
-    error: m(() => n.value)
+    resolved: m(() => r.value),
+    error: m(() => c.value)
   };
 }
-function g() {
+function w() {
   return T();
 }
-const q = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  createPromiseCallback: I,
-  genId: g
+  createPromiseCallback: g,
+  genId: w
 }, Symbol.toStringTag, { value: "Module" }));
-function D(r, o, a = !1, n = !1) {
-  let e = P("0");
-  const t = {}, i = S([]);
-  function u(c, d, s, l, p) {
-    const _ = k(e.value), z = E([l, p], ([H, R]) => {
-      (!t[_] || H || a && R) && (z(), delete t[_]);
+function G(s, i, u = !1, c = !1) {
+  let t = P("0");
+  const r = {}, e = S([]);
+  function n(l, f, a, d, p) {
+    const _ = k(t.value), z = b([d, p], ([j, R]) => {
+      (!r[_] || j || u && R) && (z(), delete r[_]);
     });
-    t[_] = {
-      data: w(c),
-      reply: d,
-      onError: s,
-      resolved: l,
+    r[_] = {
+      data: I(l),
+      reply: f,
+      onError: a,
+      resolved: d,
       error: p
-    }, e.value = _;
+    }, t.value = _;
   }
-  const f = (c) => {
-    const d = E(e, (s) => {
-      if (!(!t[s] || t[s].resolved.value || a && t[s].error.value))
+  const o = (l) => {
+    const f = b(t, (a) => {
+      if (!(!r[a] || r[a].resolved.value || u && r[a].error.value))
         try {
-          c({
-            data: t[s].data,
-            version: s,
-            reply: t[s].reply
+          l({
+            data: r[a].data,
+            version: a,
+            reply: r[a].reply
           });
-        } catch (l) {
-          t[s].error.value || t[s].onError(l);
+        } catch (d) {
+          r[a].error.value || r[a].onError(d);
         }
     });
-    return i.push(d), t[e.value] && C(e), d;
-  }, v = async (c) => {
-    const { promise: d, callback: s, resolved: l, error: p, onError: _ } = I(o, a, n);
-    u(c, s, _, l, p), await d;
+    return e.push(f), r[t.value] && C(t), f;
+  }, v = async (l) => {
+    const { promise: f, callback: a, resolved: d, error: p, onError: _ } = g(i, u, c);
+    n(l, a, _, d, p), await f;
   }, h = {
-    latestVersion: m(() => e),
-    watchPublishRequest: f
+    latestVersion: m(() => t),
+    watchPublishRequest: o
   };
   return {
-    watchHandles: i,
+    watchHandles: e,
     publishRequest: v,
     api: h
   };
 }
-function x(r) {
-  let o = P("0");
-  const a = {}, n = S([]);
-  function e(u) {
-    const f = k(o.value);
-    a[f] = { data: w(u) }, o.value = f;
+function x(s) {
+  let i = P("0");
+  const u = {}, c = S([]);
+  function t(n) {
+    const o = k(i.value);
+    u[o] = { data: I(n) }, i.value = o;
   }
-  const t = (u) => E(o, (f) => {
-    u({
-      data: a[f].data,
-      version: f
+  const r = (n) => b(i, (o) => {
+    n({
+      data: u[o].data,
+      version: o
     });
-  }), i = {
-    latestVersion: m(() => o),
-    watchPublish: t
+  }), e = {
+    latestVersion: m(() => i),
+    watchPublish: r
   };
   return {
-    watchHandles: n,
-    publish: async (u) => {
-      e(u);
+    watchHandles: c,
+    publish: async (n) => {
+      t(n);
     },
-    api: i
+    api: e
   };
 }
-function k(r) {
-  if (+r < Number.MAX_SAFE_INTEGER)
-    return (parseInt(r) + 1).toString();
-  let o = r.split("").reverse().join(""), a = "1";
-  const n = Math.max(o.length, a.length);
-  let e = 0, t = [];
-  for (let i = 0; i < n; i++) {
-    const u = i < o.length ? parseInt(o[i], 10) : 0, f = i < a.length ? parseInt(a[i], 10) : 0, v = u + f + e;
-    t.push(v % 10), e = Math.floor(v / 10);
+function k(s) {
+  if (+s < Number.MAX_SAFE_INTEGER)
+    return (parseInt(s) + 1).toString();
+  let i = s.split("").reverse().join(""), u = "1";
+  const c = Math.max(i.length, u.length);
+  let t = 0, r = [];
+  for (let e = 0; e < c; e++) {
+    const n = e < i.length ? parseInt(i[e], 10) : 0, o = e < u.length ? parseInt(u[e], 10) : 0, v = n + o + t;
+    r.push(v % 10), t = Math.floor(v / 10);
   }
-  return e > 0 && t.push(e), t.reverse().join("");
+  return t > 0 && r.push(t), r.reverse().join("");
 }
-function A() {
-  const r = {}, o = {}, a = /* @__PURE__ */ new WeakMap(), n = {};
+function A(s) {
+  const i = {}, u = {}, c = /* @__PURE__ */ new WeakMap(), t = {}, r = [];
   return Object.freeze({
     registerAgg(e) {
       if (e.isInitialized.value)
         throw new Error("Agg must register before initialized");
-      if (n[e.__id])
+      if (t[e.__id])
         throw new Error("Agg already registered");
       e.type === "MultiInstance" && e.api.events.destroyed.watchPublish(() => {
-        delete n[e.__id];
-      }), n[e.__id] = e;
-      const t = [];
-      for (const i of Object.values(r))
-        i.mount({ api: e.api, __aggId: e.__id, isInitialized: e.isInitialized });
-      for (const i of Object.values(o))
-        i.mount({ api: e.api, __aggId: e.__id }), t.push(i.__id);
-      a.set(e, t);
+        delete t[e.__id];
+      }), t[e.__id] = e;
+      const n = [];
+      for (const o of Object.values(i))
+        o.mount({ api: e.api, __aggId: e.__id, isInitialized: e.isInitialized });
+      for (const o of Object.values(u))
+        o.mount({ api: e.api, __aggId: e.__id }), n.push(o.__id);
+      if (c.set(e, n), B(e)) {
+        const o = e.api.events.destroyed.watchPublish(() => {
+          delete t[e.__id], s?.(e);
+          for (const v of r)
+            v(e);
+          o?.();
+        });
+      }
+    },
+    onDestroy(e) {
+      r.push(e);
     },
     createSetupPlugin(e) {
-      let t;
-      return e instanceof Function ? t = e() : t = e, Object.freeze({
-        __id: g(),
+      let n;
+      return e instanceof Function ? n = e() : n = e, Object.freeze({
+        __id: w(),
         type: "Setup",
-        mount(i) {
-          if (i.isInitialized.value)
+        mount(o) {
+          if (o.isInitialized.value)
             throw new Error("Can not setup after initialized");
-          t.mount({ api: i.api, __aggId: i.__aggId });
+          n.mount({ api: o.api, __aggId: o.__aggId });
         }
       });
     },
     createHotSwapPlugin(e) {
-      let t;
-      return e instanceof Function ? t = e() : t = e, Object.freeze({
-        __id: g(),
+      let n;
+      return e instanceof Function ? n = e() : n = e, Object.freeze({
+        __id: w(),
         type: "HotSwap",
-        mount: t.mount,
-        unmount: t.unmount
+        mount: n.mount,
+        unmount: n.unmount
       });
     },
     registerPlugin(e) {
       if (e.type === "Setup") {
-        if (r[e.__id])
+        if (i[e.__id])
           throw new Error("Plugin already registered");
-        r[e.__id] = e;
-        for (const t in n)
+        i[e.__id] = e;
+        for (const n in t)
           e.mount({
-            api: n[t].api,
-            __aggId: n[t].__id,
-            isInitialized: n[t].isInitialized
+            api: t[n].api,
+            __aggId: t[n].__id,
+            isInitialized: t[n].isInitialized
           });
       } else if (e.type === "HotSwap") {
-        o[e.__id] = e;
-        for (const t in n)
-          a.has(n[t]) && !a.get(n[t]).includes(e.__id) && (e.mount({ api: n[t].api, __aggId: n[t].__id }), a.get(n[t]).push(e.__id));
+        u[e.__id] = e;
+        for (const n in t)
+          c.has(t[n]) && !c.get(t[n]).includes(e.__id) && (e.mount({ api: t[n].api, __aggId: t[n].__id }), c.get(t[n]).push(e.__id));
       } else
         isNever(e);
     },
@@ -201,165 +211,170 @@ function A() {
       if (e.type === "Setup")
         throw new Error("Can not unregister setup plugin");
       if (e.type === "HotSwap") {
-        for (const t in n)
-          a.has(n[t]) && a.get(n[t]).includes(e.__id) && e.unmount({ api: n[t].api, __aggId: n[t].__id });
-        delete o[e.__id];
+        for (const n in t)
+          c.has(t[n]) && c.get(t[n]).includes(e.__id) && e.unmount({ api: t[n].api, __aggId: t[n].__id });
+        delete u[e.__id];
       } else
         isNever(e);
     }
   });
 }
-function G(r) {
-  return A();
+function U(s, i) {
+  return A(i);
 }
-function U(r) {
+function W(s) {
   return A();
 }
-function B(r) {
-  return j(r);
+function B(s) {
+  return s.type === "MultiInstance";
+}
+function N(s) {
+  return H(s);
 }
-function N(r) {
-  const o = j(r);
+function O(s) {
+  const i = H(s);
   return y({
-    states: o.states,
-    commands: o.commands,
-    events: o.events
+    states: i.states,
+    commands: i.commands,
+    events: i.events
   });
 }
-function j(r) {
-  const o = r.states;
-  for (const i of Object.keys(r.states))
-    o[i] = w(o[i]);
-  const a = y(r.states), n = w(r.commands), e = {}, t = r.events;
-  for (const i in r.events)
-    e[i] = t[i].api;
+function H(s) {
+  const i = s.states;
+  for (const e of Object.keys(s.states))
+    i[e] = I(i[e]);
+  const u = y(s.states), c = I(s.commands), t = {}, r = s.events;
+  for (const e in s.events)
+    t[e] = r[e].api;
   return y({
-    states: a,
-    commands: n,
-    events: y(e),
-    destroy: r.destroy
+    states: u,
+    commands: c,
+    events: y(t),
+    destroy: s.destroy
   });
 }
-function W(r, o) {
+function X(s, i) {
   const {
-    callback: a,
-    onError: n,
-    promise: e,
-    resolved: t
-  } = I(() => {
+    callback: u,
+    onError: c,
+    promise: t,
+    resolved: r
+  } = g(() => {
   }, !1, 5e3);
-  function i(p) {
-    if (t.value === !0)
+  function e(p) {
+    if (r.value === !0)
       throw new Error("Agg already initialized");
-    u.push(p());
+    n.push(p());
   }
-  const u = [];
+  const n = [];
   setTimeout(
-    () => Promise.all(u).then(() => {
-      a();
+    () => Promise.all(n).then(() => {
+      u();
     }).catch((p) => {
-      n(p);
-    })
+      c(p);
+    }),
+    0
   );
-  const f = F(), v = f.run(
-    () => o({
+  const o = M(), v = o.run(
+    () => i({
       getCurrentScope() {
-        return f;
+        return o;
       },
-      onScopeDispose: M,
+      onScopeDispose: F,
       onCreated(p) {
         Promise.resolve().then(p);
       },
-      onBeforeInitialize: i,
-      isInitialized: m(() => t.value),
-      untilInitialized: e
+      onBeforeInitialize: e,
+      isInitialized: m(() => r.value),
+      untilInitialized: t
     })
-  ), h = v.states || {}, c = v.commands || {}, d = v.events || {};
-  let s;
-  d.destroyed ? s = d.destroyed : (s = x(), d.destroyed = s);
-  let l = v.destroy;
-  return l || (l = () => {
-    s?.publish({});
-    for (const p in d) {
-      const _ = d[p];
+  ), h = v.states || {}, l = v.commands || {}, f = v.events || {};
+  let a;
+  f.destroyed ? a = f.destroyed : (a = x(), f.destroyed = a);
+  let d = v.destroy;
+  return d || (d = () => {
+    a?.publish({});
+    for (const p in f) {
+      const _ = f[p];
       for (const z of _.watchHandles)
         z.stop();
     }
-    f.stop();
+    o.stop();
   }), y({
-    __id: g(),
+    __id: w(),
     type: "MultiInstance",
-    id: r,
-    api: B({
+    id: s,
+    api: N({
       states: h,
-      commands: c,
-      events: d,
-      destroy: l
+      commands: l,
+      events: f,
+      destroy: d
     }),
-    isInitialized: t,
+    isInitialized: r,
     async untilInitialized() {
-      return await e.catch((p) => {
+      return await t.catch((p) => {
         throw new Error(`Failed to initialize Agg: ${p.message}
 Stack : ${p.stack || "unkown"}`);
       });
     }
   });
 }
-function X(r) {
+function J(s) {
   const {
-    callback: o,
-    onError: a,
-    promise: n,
-    resolved: e
-  } = I(() => {
+    callback: i,
+    onError: u,
+    promise: c,
+    resolved: t
+  } = g(() => {
   }, !1, 5e3);
-  function t(c) {
-    if (e.value === !0)
+  function r(l) {
+    if (t.value === !0)
       throw new Error("Agg already initialized");
-    i.push(c());
+    e.push(l());
   }
-  const i = [], u = r({
-    onCreated(c) {
-      Promise.resolve().then(c);
+  const e = [], n = s({
+    onCreated(l) {
+      Promise.resolve().then(l);
     },
-    onBeforeInitialize: t,
-    isInitialized: m(() => e.value),
-    untilInitialized: n
+    onBeforeInitialize: r,
+    isInitialized: m(() => t.value),
+    untilInitialized: c
   });
   setTimeout(
-    () => Promise.all(i).then(() => {
-      o();
-    }).catch((c) => {
-      a(c);
-    })
+    () => Promise.all(e).then(() => {
+      i();
+    }).catch((l) => {
+      u(l);
+    }),
+    0
   );
-  const f = u.states || {}, v = u.commands || {}, h = u.events || {};
+  const o = n.states || {}, v = n.commands || {}, h = n.events || {};
   return {
-    __id: g(),
+    __id: w(),
     type: "Singleton",
-    api: N({
-      states: f,
+    api: O({
+      states: o,
       commands: v,
       events: h,
       destroy: () => {
       }
     }),
-    isInitialized: e,
+    isInitialized: t,
     async untilInitialized() {
-      return await n.catch((c) => {
-        throw new Error(`Failed to initialize Agg: ${c.message}
-Stack : ${c.stack || "unkown"}`);
+      return await c.catch((l) => {
+        throw new Error(`Failed to initialize Agg: ${l.message}
+Stack : ${l.stack || "unkown"}`);
       });
     }
   };
 }
 export {
-  q as Utils,
+  D as Utils,
   x as createBroadcastEvent,
-  W as createMultiInstanceAgg,
-  U as createPluginHelperByAgg,
-  G as createPluginHelperByAggCreator,
-  D as createRequestEvent,
-  X as createSingletonAgg
+  X as createMultiInstanceAgg,
+  W as createPluginHelperByAgg,
+  U as createPluginHelperByAggCreator,
+  G as createRequestEvent,
+  J as createSingletonAgg
 };
 //# sourceMappingURL=index.mjs.map