@doeixd/machine 0.0.21 → 0.0.23

package/dist/esm/development/index.js

@@ -1434,6 +1434,104 @@ function withDebugging(machine) {
   return withTimeTravel(withSnapshot(withHistory(machine)));
 }
 
+// src/mixins.ts
+function getAllPropertyDescriptors(obj) {
+  const descriptors = {};
+  let current = obj;
+  while (current && current !== Object.prototype) {
+    const props = Object.getOwnPropertyDescriptors(current);
+    for (const [key, desc] of Object.entries(props)) {
+      if (key === "constructor") continue;
+      if (!(key in descriptors)) {
+        descriptors[key] = desc;
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return descriptors;
+}
+function MachineUnion(...machines) {
+  const Base = machines[0];
+  class CombinedMachine extends Base {
+    constructor(context) {
+      super(context);
+    }
+  }
+  const wrapMethod = (fn) => {
+    return function(...args) {
+      const result = fn.apply(this, args);
+      if (result && typeof result === "object" && "context" in result) {
+        const newContext = { ...this.context, ...result.context };
+        return new CombinedMachine(newContext);
+      }
+      return result;
+    };
+  };
+  for (const machine of machines) {
+    const descriptors = getAllPropertyDescriptors(machine.prototype);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (key === "constructor") continue;
+      if (typeof descriptor.value === "function") {
+        const originalFn = descriptor.value;
+        const wrappedFn = wrapMethod(originalFn);
+        Object.defineProperty(CombinedMachine.prototype, key, {
+          ...descriptor,
+          value: wrappedFn
+        });
+      } else {
+        Object.defineProperty(CombinedMachine.prototype, key, descriptor);
+      }
+    }
+  }
+  return CombinedMachine;
+}
+function MachineExclude(Source, ...Excluded) {
+  class ExcludedMachine extends MachineBase {
+    constructor(context) {
+      super(context);
+    }
+  }
+  const sourceDescriptors = getAllPropertyDescriptors(Source.prototype);
+  for (const [key, descriptor] of Object.entries(sourceDescriptors)) {
+    if (key === "constructor") continue;
+    if (typeof descriptor.value === "function") {
+      const originalFn = descriptor.value;
+      const wrappedFn = function(...args) {
+        const result = originalFn.apply(this, args);
+        if (result && typeof result === "object" && "context" in result) {
+          return new ExcludedMachine({ ...this.context, ...result.context });
+        }
+        return result;
+      };
+      Object.defineProperty(ExcludedMachine.prototype, key, { ...descriptor, value: wrappedFn });
+    } else {
+      Object.defineProperty(ExcludedMachine.prototype, key, descriptor);
+    }
+  }
+  for (const Excl of Excluded) {
+    const excludedDescriptors = getAllPropertyDescriptors(Excl.prototype);
+    for (const key of Object.keys(excludedDescriptors)) {
+      if (Object.prototype.hasOwnProperty.call(ExcludedMachine.prototype, key)) {
+        delete ExcludedMachine.prototype[key];
+      }
+    }
+  }
+  return ExcludedMachine;
+}
+function machineUnion(...instances) {
+  const constructors = instances.map((i) => i.constructor);
+  const contexts = instances.map((i) => i.context);
+  const mergedContext = Object.assign({}, ...contexts);
+  const CombinedClass = MachineUnion(...constructors);
+  return new CombinedClass(mergedContext);
+}
+function machineExclude(source, ...excluded) {
+  const sourceCtor = source.constructor;
+  const excludedCtors = excluded.map((e) => e.constructor);
+  const ExcludedClass = MachineExclude(sourceCtor, ...excludedCtors);
+  return new ExcludedClass(source.context);
+}
+
 // src/utils.ts
 function isState(machine, machineClass) {
   return machine instanceof machineClass;
@@ -2036,6 +2134,8 @@ export {
   CANCEL,
   META_KEY,
   MachineBase,
+  MachineExclude,
+  MachineUnion,
   MiddlewareBuilder,
   MultiMachineBase,
   action,
@@ -2098,6 +2198,8 @@ export {
   isPipelineConfig,
   isState,
   logState,
+  machineExclude,
+  machineUnion,
   matchMachine,
   mergeContext,
   metadata,