vue-fn 0.3.0-rc → 0.4.1-rc

package/README.md

@@ -1,5 +1,67 @@
 # vue-fn
 
-一个 vue3 的响应式函数工具包
+A Vue 3 reactive function utility library providing domain-driven design patterns and reactive state management utilities.
 
-[文档地址](https://alphafoxz.github.io/vue-fn)
+## Features
+
+- **Domain-Driven Design** - Functional implementation of DDD patterns with events, aggregations, and plugins
+- **Modular Architecture** - Multiple independently consumable modules with tree-shaking support
+- **Vue 3 Reactive** - Built on `@vue/reactivity` for full reactive system integration
+- **Type Safety** - Complete TypeScript support for excellent developer experience
+- **Client/Server** - Separate `domain` module for browsers, `domain-server` for Node.js environments
+- **Cross-Tab State** - `shared-domain` module provides cross-tab/window state sharing via BroadcastChannel API
+- **Two-Way Binding** - `bindRef` and `bindReactive` utilities for reactive data binding
+
+## Modules
+
+| Package                                       | Description                                                                                  |
+| :-------------------------------------------- | :------------------------------------------------------------------------------------------- |
+| [`@vue-fn/domain`](libs/domain)               | Vue-reactive domain implementation with aggregations, plugins, and event system              |
+| [`@vue-fn/domain-server`](libs/domain-server) | Server-side variant for Node.js environments                                                 |
+| [`@vue-fn/domain-shared`](libs/domain-shared) | Cross-tab/window shared state using BroadcastChannel API                                     |
+| [`@vue-fn/timer`](libs/timer)                 | Async utilities: `createTimeout()` for cancellable timeouts, `createDeferred()` for promises |
+
+## Documentation
+
+Full documentation is available at [https://alphafoxz.github.io/vue-fn](https://alphafoxz.github.io/vue-fn)
+
+## Installation
+
+```bash
+# Install the main domain module
+npm install @vue-fn/domain
+
+# Install other modules as needed
+npm install @vue-fn/domain-shared
+npm install @vue-fn/timer
+```
+
+## Quick Start
+
+```typescript
+import { createSingletonAgg } from '@vue-fn/domain';
+import { ref } from 'vue';
+
+const counter = createSingletonAgg(() => {
+  const count = ref(0);
+
+  return {
+    states: {
+      count,
+    },
+    commands: {
+      increment() {
+        count.value++;
+      },
+    },
+  };
+});
+
+// Use the aggregation
+counter.api.commands.increment();
+console.log(counter.api.states.count.value); // 1
+```
+
+## License
+
+UNLICENSED

package/domain/bind.d.ts

@@ -10,4 +10,7 @@ type InferValue<T> = T extends () => infer R ? R : T extends Readonly<Ref<any>>
 export declare function bindRef<STATE extends DomainAggState | SingleFieldRef, T extends InferValue<STATE>>(aggState: STATE, onChange: WatchCallback<T>, watchOptions?: WatchOptions & {
     forceSync?: boolean;
 }): Ref<T>;
+export declare function bindReactive<STATE extends DomainAggReactiveState, T extends InferValue<STATE> & object>(aggState: STATE, onChange: WatchCallback<T>, watchOptions?: WatchOptions & {
+    forceSync?: boolean;
+}): Reactive<T>;
 export {};

package/domain/event.d.ts

@@ -11,19 +11,19 @@ export type DomainRequestEvent<DATA, REPLY_DATA> = {
     listeners: DomainRequestEventListener<DATA, REPLY_DATA>[];
     publishRequest: (data: DeepReadonly<UnwrapNestedRefs<DATA>>) => Promise<REPLY_DATA>;
     api: {
-        latestVersion: Readonly<string>;
+        readonly latestVersion: string;
         listenAndReply: (replyFn: DomainRequestEventListener<DATA, REPLY_DATA>) => () => void;
     };
 };
 export type DomainRequestEventListener<DATA, REPLY_DATA> = (param: {
-    data: DeepReadonly<UnwrapNestedRefs<DATA>>;
-    version: string;
+    readonly data: DeepReadonly<UnwrapNestedRefs<DATA>>;
+    readonly version: string;
 }) => REPLY_DATA;
 export type DomainBroadcastEvent<DATA> = {
     listeners: DomainBroadcastEventListener<DATA>[];
     publish: (data: DeepReadonly<UnwrapNestedRefs<DATA>>) => void;
     api: {
-        latestVersion: Readonly<string>;
+        readonly latestVersion: string;
         listen: (cb: (event: {
             data: DeepReadonly<UnwrapNestedRefs<DATA>>;
             version: string;
@@ -31,8 +31,8 @@ export type DomainBroadcastEvent<DATA> = {
     };
 };
 export type DomainBroadcastEventListener<DATA> = (param: {
-    data: DeepReadonly<UnwrapNestedRefs<DATA>>;
-    version: string;
+    readonly data: DeepReadonly<UnwrapNestedRefs<DATA>>;
+    readonly version: string;
 }) => void;
 export type DomainDestroyedEventApi = DomainBroadcastEvent<{}>['api'];
 export type DomainEvent<DATA, REPLY_DATA> = DomainRequestEvent<DATA, REPLY_DATA> | DomainBroadcastEvent<DATA>;

package/domain/index.d.ts

@@ -4,5 +4,5 @@ export type { DomainPlugin, DomainHotSwapPlugin, DomainSetupPlugin } from './plu
 export { createPluginHelperByAgg, createPluginHelperByAggCreator } from './plugin';
 export type { DomainSingletonAgg, DomainMultiInstanceAgg } from './agg';
 export { createSingletonAgg, createMultiInstanceAgg } from './agg';
-export { bindRef } from './bind';
+export { bindRef, bindReactive } from './bind';
 export * as Utils from './common';

package/domain/index.mjs

@@ -1,33 +1,33 @@
-import { t as h } from "../index-Dhhr_iXc.js";
-import { ref as z, computed as g, effectScope as x, onScopeDispose as P, shallowReadonly as w, readonly as S, watch as E, isReactive as R, isRef as O, unref as T } from "vue";
-function B() {
+import { t as z } from "../index-BcykEFlB.js";
+import { ref as S, computed as E, effectScope as P, onScopeDispose as R, shallowReadonly as I, readonly as h, watch as v, reactive as T, isReactive as D, isRef as C, unref as N } from "vue";
+function F() {
   function e(t) {
     let o = "0", i = [];
     const r = [];
-    function c(s, u, a, p) {
-      const f = A(o);
-      o = f, i.push({
-        version: f,
+    function c(s, u, f, p) {
+      const a = A(o);
+      o = a, i.push({
+        version: a,
         data: s,
         resolve: u,
-        reject: a,
+        reject: f,
         timerId: p
       }), n();
     }
     function n() {
       if (!(i.length === 0 || r.length === 0))
         for (const s of i) {
-          const { version: u, data: a, resolve: p, reject: f, timerId: d } = s, m = {
-            data: a,
+          const { version: u, data: f, resolve: p, reject: a, timerId: d } = s, m = {
+            data: f,
             version: u
           };
-          for (const v of r)
+          for (const w of r)
             try {
-              const l = v(m);
+              const l = w(m);
               t.onReply(l), p(l), d && clearTimeout(d);
             } catch (l) {
               if (t.onError && l instanceof Error)
-                t.onError(l), t.isTerminateOnError && (f(l), d && clearTimeout(d));
+                t.onError(l), t.isTerminateOnError && (a(l), d && clearTimeout(d));
               else
                 throw new Error("caught a unknown error" + (l?.toString() || l));
             }
@@ -37,11 +37,11 @@ function B() {
     return {
       listeners: r,
       async publishRequest(s) {
-        const u = new h.Deferred();
-        let a;
-        return t.timeoutMs && (a = setTimeout(() => {
+        const u = new z.Deferred();
+        let f;
+        return t.timeoutMs && (f = setTimeout(() => {
           u.reject(new Error(`timeout: ${t.timeoutMs} ms`));
-        }, t.timeoutMs)), c(s, u.resolve, u.reject, a), await u.promise;
+        }, t.timeoutMs)), c(s, u.resolve, u.reject, f), await u.promise;
       },
       api: {
         get latestVersion() {
@@ -62,7 +62,7 @@ function B() {
     options: e
   };
 }
-function D() {
+function O() {
   let e = "0";
   const t = [];
   return {
@@ -96,12 +96,12 @@ function A(e) {
   const i = Math.max(t.length, o.length);
   let r = 0, c = [];
   for (let n = 0; n < i; n++) {
-    const s = n < t.length ? parseInt(t[n], 10) : 0, u = n < o.length ? parseInt(o[n], 10) : 0, a = s + u + r;
-    c.push(a % 10), r = Math.floor(a / 10);
+    const s = n < t.length ? parseInt(t[n], 10) : 0, u = n < o.length ? parseInt(o[n], 10) : 0, f = s + u + r;
+    c.push(f % 10), r = Math.floor(f / 10);
   }
   return r > 0 && c.push(r), c.reverse().join("");
 }
-function I(e = "") {
+function g(e = "") {
   const t = Date.now().toString(36), o = Math.random().toString(36).substring(2, 10);
   return `${e}${t}${o}`;
 }
@@ -169,10 +169,10 @@ function _(e, t = /* @__PURE__ */ new WeakMap()) {
     o[i] = _(e[i], t);
   return o;
 }
-const F = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const L = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   deepClone: _,
-  genId: I,
+  genId: g,
   isEqual: y
 }, Symbol.toStringTag, { value: "Module" }));
 function k(e) {
@@ -195,11 +195,11 @@ function k(e) {
         });
       for (const u of Object.values(o))
         u.mount({ api: n.api, __aggId: n.__id }), s.push(u.__id);
-      if (i.set(n, s), C(n)) {
+      if (i.set(n, s), b(n)) {
         const u = n.api.events.destroyed.listen(() => {
           delete r[n.__id], e?.(n);
-          for (const a of c)
-            a(n);
+          for (const f of c)
+            f(n);
           u?.();
         });
       }
@@ -210,7 +210,7 @@ function k(e) {
     createSetupPlugin(n) {
       let s;
       return n instanceof Function ? s = n() : s = n, Object.freeze({
-        __id: I(),
+        __id: g(),
         type: "Setup",
         mount(u) {
           if (u.isInitialized.value)
@@ -222,7 +222,7 @@ function k(e) {
     createHotSwapPlugin(n) {
       let s;
       return n instanceof Function ? s = n() : s = n, Object.freeze({
-        __id: I(),
+        __id: g(),
         type: "HotSwap",
         mount: s.mount,
         unmount: s.unmount
@@ -264,21 +264,21 @@ function k(e) {
     }
   });
 }
-function L(e, t) {
+function q(e, t) {
   return k(t);
 }
-function q(e) {
+function K(e) {
   return k();
 }
-function C(e) {
+function b(e) {
   return e.type === "MultiInstance";
 }
-function N(e) {
+function H(e) {
   return j(e);
 }
-function H(e) {
+function V(e) {
   const t = j(e);
-  return w({
+  return I({
     states: t.states,
     commands: t.commands,
     events: t.events
@@ -287,24 +287,24 @@ function H(e) {
 function j(e) {
   const t = e.states;
   for (const n of Object.keys(e.states))
-    t[n] = S(t[n]);
-  const o = w(e.states), i = S(e.commands), r = {}, c = e.events;
+    t[n] = h(t[n]);
+  const o = I(e.states), i = h(e.commands), r = {}, c = e.events;
   for (const n in e.events)
     r[n] = c[n].api;
-  return w({
+  return I({
     states: o,
     commands: i,
-    events: w(r),
+    events: I(r),
     destroy: e.destroy
   });
 }
-function K(e, t) {
+function W(e, t) {
   const {
     resolve: o,
     reject: i,
     promise: r
-  } = new h.Deferred();
-  let c = z(!1);
+  } = new z.Deferred();
+  let c = S(!1);
   function n(l) {
     if (c.value === !0)
       throw new Error("Agg already initialized");
@@ -318,41 +318,41 @@ function K(e, t) {
       throw i(l), l;
     })
   );
-  const u = x(), a = u.run(
+  const u = P(), f = u.run(
     () => t({
       getCurrentScope() {
         return u;
       },
-      onScopeDispose: P,
+      onScopeDispose: R,
       onCreated(l) {
         Promise.resolve().then(l);
       },
       onBeforeInitialize: n,
-      isInitialized: g(() => c.value),
+      isInitialized: E(() => c.value),
       untilInitialized: r
     })
-  ), p = a.states || {}, f = a.commands || {}, d = a.events || {};
+  ), p = f.states || {}, a = f.commands || {}, d = f.events || {};
   let m;
-  d.destroyed ? m = d.destroyed : (m = D(), d.destroyed = m);
-  let v = a.destroy;
-  return v || (v = () => {
+  d.destroyed ? m = d.destroyed : (m = O(), d.destroyed = m);
+  let w = f.destroy;
+  return w || (w = (() => {
     m?.publish({});
     for (const l in d) {
-      const M = d[l];
-      M.listeners.length = 0;
+      const x = d[l];
+      x.listeners.length = 0;
     }
     u.stop();
-  }), w({
-    __id: I(),
+  })), I({
+    __id: g(),
     type: "MultiInstance",
     id: e,
-    api: N({
+    api: H({
       states: p,
-      commands: f,
+      commands: a,
       events: d,
-      destroy: v
+      destroy: w
     }),
-    isInitialized: g(() => c.value),
+    isInitialized: E(() => c.value),
     async untilInitialized() {
       return await r.catch((l) => {
         throw new Error(`Failed to initialize Agg: ${l.message}
@@ -361,67 +361,67 @@ Stack : ${l.stack || "unkown"}`);
     }
   });
 }
-function W(e) {
+function G(e) {
   const {
     resolve: t,
     reject: o,
     promise: i
-  } = new h.Deferred();
-  let r = z(!1);
-  function c(f) {
+  } = new z.Deferred();
+  let r = S(!1);
+  function c(a) {
     if (r.value === !0)
       throw new Error("Agg already initialized");
-    n.push(f());
+    n.push(a());
   }
   const n = [], s = e({
-    onCreated(f) {
-      Promise.resolve().then(f);
+    onCreated(a) {
+      Promise.resolve().then(a);
     },
     onBeforeInitialize: c,
-    isInitialized: g(() => r.value),
+    isInitialized: E(() => r.value),
     untilInitialized: i
   });
   setTimeout(
     () => Promise.all(n).then(() => {
       t(), r.value = !0;
-    }).catch((f) => {
-      o(f);
+    }).catch((a) => {
+      o(a);
     }),
     0
   );
-  const u = s.states || {}, a = s.commands || {}, p = s.events || {};
+  const u = s.states || {}, f = s.commands || {}, p = s.events || {};
   return {
-    __id: I(),
+    __id: g(),
     type: "Singleton",
-    api: H({
+    api: V({
       states: u,
-      commands: a,
+      commands: f,
       events: p,
       destroy: () => {
       }
     }),
-    isInitialized: g(() => r.value),
+    isInitialized: E(() => r.value),
     async untilInitialized() {
-      return await i.catch((f) => {
-        throw new Error(`Failed to initialize Agg: ${f.message}
-Stack : ${f.stack || "unkown"}`);
+      return await i.catch((a) => {
+        throw new Error(`Failed to initialize Agg: ${a.message}
+Stack : ${a.stack || "unkown"}`);
       });
     }
   };
 }
-function G(e, t, o) {
-  const i = z(V(e));
+function U(e, t, o) {
+  const i = S(M(e));
   if (!o?.forceSync)
-    return E(i, t, o), i;
+    return v(i, t, o), i;
   o.forceSync = void 0;
   let r;
-  return E(
+  return v(
     e,
     (c) => {
       r = c, i.value = c;
     },
     o
-  ), E(
+  ), v(
     i,
     (c, n, s) => {
       y(c, r) || t(c, n, s);
@@ -429,24 +429,49 @@ function G(e, t, o) {
     o
   ), i;
 }
-function V(e) {
+function X(e, t, o) {
+  const i = T(M(e));
+  if (!o?.forceSync)
+    return v(i, t, o), i;
+  o.forceSync = void 0;
+  let r = !1;
+  return v(
+    e,
+    (c) => {
+      r = !0;
+      const n = Object.keys(c);
+      for (const s of n)
+        i[s] = c[s];
+      r = !1;
+    },
+    o
+  ), v(
+    i,
+    (c, n, s) => {
+      r || t(c, n, s);
+    },
+    o
+  ), i;
+}
+function M(e) {
   let t;
   if (typeof e == "function")
     t = e();
-  else if (R(e) || O(e))
-    t = T(e);
+  else if (D(e) || C(e))
+    t = N(e);
   else
     throw new Error("invalid state");
   return typeof t == "object" && (t = _(t)), t;
 }
 export {
-  F as Utils,
-  G as bindRef,
-  D as createBroadcastEvent,
-  K as createMultiInstanceAgg,
-  q as createPluginHelperByAgg,
-  L as createPluginHelperByAggCreator,
-  B as createRequestEvent,
-  W as createSingletonAgg
+  L as Utils,
+  X as bindReactive,
+  U as bindRef,
+  O as createBroadcastEvent,
+  W as createMultiInstanceAgg,
+  K as createPluginHelperByAgg,
+  q as createPluginHelperByAggCreator,
+  F as createRequestEvent,
+  G as createSingletonAgg
 };
 //# sourceMappingURL=index.mjs.map