@doeixd/machine 0.0.21 → 0.0.22

package/dist/cjs/development/index.js

@@ -25,6 +25,8 @@ __export(src_exports, {
   CANCEL: () => CANCEL,
   META_KEY: () => META_KEY,
   MachineBase: () => MachineBase,
+  MachineExclude: () => MachineExclude,
+  MachineUnion: () => MachineUnion,
   MiddlewareBuilder: () => MiddlewareBuilder,
   MultiMachineBase: () => MultiMachineBase,
   action: () => action,
@@ -87,6 +89,8 @@ __export(src_exports, {
   isPipelineConfig: () => isPipelineConfig,
   isState: () => isState,
   logState: () => logState,
+  machineExclude: () => machineExclude,
+  machineUnion: () => machineUnion,
   matchMachine: () => matchMachine,
   mergeContext: () => mergeContext,
   metadata: () => metadata,
@@ -1563,6 +1567,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;