@rotorsoft/act 0.9.0 → 0.10.0

package/dist/index.js

@@ -1361,6 +1361,70 @@ var _this_ = ({ stream }) => ({
 });
 var _void_ = () => void 0;
 
+// src/projection-builder.ts
+function isProjection(x) {
+  return x != null && x._tag === "Projection";
+}
+function projection(target, events = {}) {
+  const defaultResolver = target ? { target } : void 0;
+  const builder = {
+    on: (entry) => {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const event = keys[0];
+      const schema = entry[event];
+      if (!(event in events)) {
+        events[event] = {
+          schema,
+          reactions: /* @__PURE__ */ new Map()
+        };
+      }
+      return {
+        do: (handler) => {
+          const reaction = {
+            handler,
+            resolver: defaultResolver ?? _this_,
+            options: {
+              blockOnError: true,
+              maxRetries: 3
+            }
+          };
+          const register = events[event];
+          const name = handler.name || `${event}_${register.reactions.size}`;
+          register.reactions.set(name, reaction);
+          const nextBuilder = projection(
+            target,
+            events
+          );
+          return {
+            ...nextBuilder,
+            to(resolver) {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: typeof resolver === "string" ? { target: resolver } : resolver
+              });
+              return nextBuilder;
+            },
+            void() {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: _void_
+              });
+              return nextBuilder;
+            }
+          };
+        }
+      };
+    },
+    build: () => ({
+      _tag: "Projection",
+      events
+    }),
+    events
+  };
+  return builder;
+}
+
 // src/slice-builder.ts
 function isSlice(x) {
   return x != null && x._tag === "Slice";
@@ -1419,6 +1483,25 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
 }) {
   const builder = {
     with: ((input) => {
+      if (isProjection(input)) {
+        for (const eventName of Object.keys(input.events)) {
+          const projRegister = input.events[eventName];
+          const existing = registry.events[eventName];
+          if (!existing) {
+            registry.events[eventName] = {
+              schema: projRegister.schema,
+              reactions: new Map(projRegister.reactions)
+            };
+          } else {
+            for (const [name, reaction] of projRegister.reactions) {
+              let key = name;
+              while (existing.reactions.has(key)) key = `${key}_p`;
+              existing.reactions.set(key, reaction);
+            }
+          }
+        }
+        return act(states, registry);
+      }
       if (isSlice(input)) {
         for (const s of input.states.values()) {
           registerState(s, states, registry.actions, registry.events);
@@ -1504,7 +1587,11 @@ function state(name, state2) {
 }
 function action_builder(state2) {
   return {
-    on(action2, schema) {
+    on(entry) {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const action2 = keys[0];
+      const schema = entry[action2];
       if (action2 in state2.actions)
         throw new Error(`Duplicate action "${action2}"`);
       const actions = { ...state2.actions, [action2]: schema };
@@ -1557,10 +1644,12 @@ export {
   dispose,
   disposeAndExit,
   extend,
+  isProjection,
   isSlice,
   logger,
   patch,
   port,
+  projection,
   sleep,
   slice,
   state,