@rotorsoft/act 0.17.1 → 0.19.0

package/dist/@types/utils.d.ts

@@ -1,102 +1,13 @@
 import { type ZodType } from "zod";
-import type { Patch, Schema } from "./types/index.js";
 /**
  * @module utils
  * @category Utilities
- * Utility functions for patching state, validation, extending objects, and async helpers.
+ * Utility functions for validation, extending objects, and async helpers.
  *
- * - Use `patch()` to immutably update state with patches.
  * - Use `validate()` to validate payloads against Zod schemas.
  * - Use `extend()` to merge and validate configuration objects.
  * - Use `sleep()` for async delays.
  */
-/**
- * Immutably applies patches to a state object, creating a new copy.
- *
- * This function performs deep merging for plain objects while preserving
- * immutability. Special types (Arrays, Dates, Maps, etc.) are replaced
- * entirely rather than merged. Setting a property to `undefined` or `null`
- * removes it from the resulting object.
- *
- * Used internally by the framework to apply event patches to state, but
- * can also be used directly for state transformations.
- *
- * **Merging rules:**
- * - Plain objects: Deep merge recursively
- * - Arrays, Dates, RegExp, Maps, Sets, TypedArrays: Replace entirely
- * - `undefined` or `null` values: Delete the property
- * - Primitives: Replace with patch value
- *
- * @param original - The original state object to patch
- * @param patches - The patches to apply (partial state)
- * @returns A new state object with patches applied
- *
- * @example Simple property update
- * ```typescript
- * import { patch } from "@rotorsoft/act";
- *
- * const state = { count: 0, name: "Alice" };
- * const updated = patch(state, { count: 5 });
- * // Result: { count: 5, name: "Alice" }
- * // Original unchanged: { count: 0, name: "Alice" }
- * ```
- *
- * @example Nested object patching
- * ```typescript
- * const state = {
- *   user: { id: 1, name: "Alice", email: "alice@example.com" },
- *   settings: { theme: "dark" }
- * };
- *
- * const updated = patch(state, {
- *   user: { email: "newemail@example.com" }
- * });
- * // Result: {
- * //   user: { id: 1, name: "Alice", email: "newemail@example.com" },
- * //   settings: { theme: "dark" }
- * // }
- * ```
- *
- * @example Property deletion
- * ```typescript
- * const state = { count: 5, temp: "value", flag: true };
- *
- * const updated = patch(state, {
- *   temp: undefined,  // Delete temp
- *   flag: null        // Delete flag
- * });
- * // Result: { count: 5 }
- * ```
- *
- * @example Array replacement (not merged)
- * ```typescript
- * const state = { items: [1, 2, 3], meta: { count: 3 } };
- *
- * const updated = patch(state, {
- *   items: [4, 5]  // Arrays are replaced, not merged
- * });
- * // Result: { items: [4, 5], meta: { count: 3 } }
- * ```
- *
- * @example In event handlers
- * ```typescript
- * import { state } from "@rotorsoft/act";
- * import { z } from "zod";
- *
- * const Counter = state({ Counter: z.object({ count: z.number() }) })
- *   .init(() => ({ count: 0 }))
- *   .emits({ Incremented: z.object({ by: z.number() }) })
- *   .patch({
- *     Incremented: (event, state) => {
- *       // patch() is called internally here
- *       return { count: state.count + event.data.by };
- *     }
- *   });
- * ```
- *
- * @see {@link Patch} for the patch type definition
- */
-export declare const patch: <S extends Schema>(original: Readonly<S>, patches: Readonly<Patch<S>>) => Readonly<S>;
 /**
  * Validates a payload against a Zod schema.
  *

package/dist/@types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,OAAO,EAAiB,MAAM,KAAK,CAAC;AAEjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA+BtD;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,MAAM,EACpC,UAAU,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAC1B,QAAQ,CAAC,CAAC,CAgBZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,MAAM,EACd,SAAS,QAAQ,CAAC,CAAC,CAAC,EACpB,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,QAAQ,CAAC,CAAC,CAaZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AACH,eAAO,MAAM,MAAM,GACjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,QAAQ,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,OAAO,CAAC,CAAC,CAAC,EAClB,SAAS,QAAQ,CAAC,CAAC,CAAC,KACnB,QAAQ,CAAC,CAAC,GAAG,CAAC,CAGhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAsB,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,oBAEtC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,OAAO,EAAiB,MAAM,KAAK,CAAC;AAIjE;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,MAAM,EACd,SAAS,QAAQ,CAAC,CAAC,CAAC,EACpB,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,QAAQ,CAAC,CAAC,CAaZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AACH,eAAO,MAAM,MAAM,GACjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,QAAQ,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,OAAO,CAAC,CAAC,CAAC,EAClB,SAAS,QAAQ,CAAC,CAAC,CAAC,KACnB,QAAQ,CAAC,CAAC,GAAG,CAAC,CAGhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAsB,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,oBAEtC"}

package/dist/index.cjs

@@ -54,7 +54,6 @@ __export(index_exports, {
   disposeAndExit: () => disposeAndExit,
   extend: () => extend,
   logger: () => logger,
-  patch: () => patch,
   port: () => port,
   projection: () => projection,
   sleep: () => sleep,
@@ -206,40 +205,6 @@ var config = () => {
 };
 
 // src/utils.ts
-var UNMERGEABLES = [
-  RegExp,
-  Date,
-  Array,
-  Map,
-  Set,
-  WeakMap,
-  WeakSet,
-  ArrayBuffer,
-  SharedArrayBuffer,
-  DataView,
-  Int8Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Int16Array,
-  Uint16Array,
-  Int32Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array
-];
-var is_mergeable = (value) => !!value && typeof value === "object" && !UNMERGEABLES.some((t) => value instanceof t);
-var patch = (original, patches) => {
-  const copy = {};
-  Object.keys({ ...original, ...patches }).forEach((key) => {
-    const patched_value = patches[key];
-    const original_value = original[key];
-    const patched = patches && key in patches;
-    const deleted = patched && (typeof patched_value === "undefined" || patched_value === null);
-    const value = patched && !deleted ? patched_value : original_value;
-    !deleted && (copy[key] = is_mergeable(value) ? patch(original_value || {}, patched_value || {}) : value);
-  });
-  return copy;
-};
 var validate = (target, payload, schema) => {
   try {
     return schema ? schema.parse(payload) : payload;
@@ -636,6 +601,7 @@ var import_crypto2 = require("crypto");
 var import_events = __toESM(require("events"), 1);
 
 // src/event-sourcing.ts
+var import_act_patch = require("@rotorsoft/act-patch");
 var import_crypto = require("crypto");
 async function snap(snapshot) {
   try {
@@ -668,7 +634,7 @@ async function load(me, stream, callback) {
         snaps++;
         patches = 0;
       } else if (me.patch[e.name]) {
-        state2 = patch(state2, me.patch[e.name](event, state2));
+        state2 = (0, import_act_patch.patch)(state2, me.patch[e.name](event, state2));
         patches++;
       }
       callback && callback({ event, state: state2, patches, snaps });
@@ -740,9 +706,10 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   );
   let { state: state2, patches } = snapshot;
   const snapshots = committed.map((event) => {
-    state2 = patch(state2, me.patch[event.name](event, state2));
+    const p = me.patch[event.name](event, state2);
+    state2 = (0, import_act_patch.patch)(state2, p);
     patches++;
-    return { event, state: state2, patches, snaps: snapshot.snaps };
+    return { event, state: state2, patches, snaps: snapshot.snaps, patch: p };
   });
   const last = snapshots.at(-1);
   me.snap && me.snap(last) && void snap(last);
@@ -1820,7 +1787,6 @@ function action_builder(state2) {
   disposeAndExit,
   extend,
   logger,
-  patch,
   port,
   projection,
   sleep,