@xstate/effect 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/xstate-effect-atom.js

@@ -1,8 +1,8 @@
 import { Cause } from 'effect';
 import { Atom, AsyncResult } from 'effect/reactivity';
-import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-a2e5cb31.js';
-export { N as NotReadyError } from './state-a2e5cb31.js';
-import 'xstate';
+import { StateMachine } from 'xstate';
+import { c as createEffectActor, a as causeFromError, N as NotReadyError, t as taggedState } from './state-83513b45.js';
+export { N as NotReadyError } from './state-83513b45.js';
 import 'xstate/durable';
 
 /**
@@ -11,6 +11,8 @@ import 'xstate/durable';
  * framework, such as `@effect/atom-react`.
  */
 
+/** @experimental */
+
 /**
  * Creates atoms for an actor that runs in an `Atom.runtime`. The runtime's
  * Layer must provide every service the logic requires; a missing service is
@@ -22,6 +24,8 @@ import 'xstate/durable';
  * when the atom is released. Wrap the atoms with `Atom.keepAlive` to pin the
  * actor for the registry's lifetime, or with `Atom.family` to create one
  * actor per input.
+ *
+ * @experimental
  */
 function createActorAtoms(runtime, logic, ...[options]) {
   const host = runtime;
@@ -55,7 +59,7 @@ function createActorAtoms(runtime, logic, ...[options]) {
     }
     const value = current.value;
     if (value.status === 'error') {
-      return AsyncResult.failureWithPrevious(Cause.fail(value.error), {
+      return AsyncResult.failureWithPrevious(causeFromError(value.error), {
         previous: get.self()
       });
     }
@@ -75,15 +79,17 @@ function createActorAtoms(runtime, logic, ...[options]) {
   function select(selector) {
     return Atom.map(snapshot, result => AsyncResult.map(result, selector));
   }
-  const state = select(current => taggedState(current));
-  return {
+  const base = {
     actor,
     snapshot,
     result,
     send: sendAtom,
-    select,
-    state
+    select
   };
+  return logic instanceof StateMachine ? {
+    ...base,
+    state: select(current => taggedState(current))
+  } : base;
 }
 
 export { createActorAtoms };

package/dist/xstate-effect-oxlint.d.ts

@@ -0,0 +1,3 @@
+export * from "./declarations/src/oxlint.js";
+export { default } from "./declarations/src/oxlint.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLWVmZmVjdC1veGxpbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4vZGVjbGFyYXRpb25zL3NyYy9veGxpbnQuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/dist/xstate-effect-oxlint.js

@@ -0,0 +1,126 @@
+import { defineRule, definePlugin } from '@oxlint/plugins';
+
+const ENQUEUE_NAMES = new Set(['enq', 'enqueue']);
+const EFFECT_LOGIC_CONSTRUCTORS = new Set(['createEffectLogic', 'createEffectStreamLogic', 'createEffectEventStreamLogic']);
+const isNode = value => typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string';
+const rootIdentifier = node => {
+  let current = node;
+  for (;;) {
+    if (current.type === 'CallExpression') {
+      current = current.callee;
+    } else if (current.type === 'MemberExpression') {
+      current = current.object;
+    } else if (current.type === 'Identifier') {
+      return current.name;
+    } else {
+      return undefined;
+    }
+  }
+};
+const returnedExpressions = fn => {
+  if (fn.body === null) {
+    return [];
+  }
+  if (fn.body.type !== 'BlockStatement') {
+    return [fn.body];
+  }
+  const found = [];
+  const visit = node => {
+    if (node.type === 'ReturnStatement') {
+      if (node.argument) {
+        found.push(node.argument);
+      }
+      return;
+    }
+    if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration') {
+      return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === 'parent') {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isNode(item)) {
+            visit(item);
+          }
+        }
+      } else if (isNode(value)) {
+        visit(value);
+      }
+    }
+  };
+  visit(fn.body);
+  return found;
+};
+const isPromiseResolve = node => node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'Promise' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve';
+const isEffectExpression = node => {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  if (isPromiseResolve(node)) {
+    const [argument] = node.arguments;
+    return argument !== undefined && isEffectExpression(argument);
+  }
+  return rootIdentifier(node) === 'Effect';
+};
+const isInlineEffectLogic = node => node.type === 'CallExpression' && node.callee.type === 'Identifier' && EFFECT_LOGIC_CONSTRUCTORS.has(node.callee.name);
+const isFunctionNode = node => node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression';
+const noInlineEffect = defineRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const {
+          callee
+        } = node;
+        if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && ENQUEUE_NAMES.has(callee.object.name) && callee.property.type === 'Identifier' && callee.property.name === 'spawn') {
+          const [logic] = node.arguments;
+          if (logic !== undefined && isInlineEffectLogic(logic)) {
+            context.report({
+              messageId: 'inlineSpawn',
+              node: logic
+            });
+          }
+          return;
+        }
+        if (callee.type !== 'Identifier' || !ENQUEUE_NAMES.has(callee.name)) {
+          return;
+        }
+        const [action] = node.arguments;
+        if (action === undefined || !isFunctionNode(action)) {
+          return;
+        }
+        for (const expression of returnedExpressions(action)) {
+          if (isEffectExpression(expression)) {
+            context.report({
+              messageId: 'inlineAction',
+              node: expression
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: 'Disallow Effects in inline enqueue callbacks and inline Effect logic in enq.spawn; declare them in setupEffect({ actions }) or actors.'
+    },
+    messages: {
+      inlineAction: 'An Effect returned from an inline action is discarded. Declare it in setupEffect({ actions }) and run it with enq(args.actions.name, args).',
+      inlineSpawn: 'Inline Effect logic passed to enq.spawn is invisible to RequirementsFrom and rejected at runtime. Declare it in actors and spawn args.actors.name.'
+    },
+    type: 'problem'
+  }
+});
+
+/** @experimental */
+var oxlint = definePlugin({
+  meta: {
+    name: 'xstate-effect'
+  },
+  rules: {
+    'no-inline-effect': noInlineEffect
+  }
+});
+
+export { oxlint as default };

package/dist/xstate-effect-test.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/test.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLWVmZmVjdC10ZXN0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvdGVzdC5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=

package/dist/xstate-effect-test.js

@@ -0,0 +1 @@
+export { s as sendAndAwait } from './sendAndAwait-bf1d4117.js';