@xstate/effect 1.0.0-alpha.8 → 1.0.0-beta.0

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,13 @@
+/**
+ * Sends one mailbox item and awaits its macrostep publication and immediate
+ * effect scheduling. Ignored events are acknowledged too. Does not await
+ * invoked work, background actions or future timers. Interrupting the waiter
+ * detaches its receipt without retracting the event.
+ *
+ * @experimental
+ */
+function sendAndAwait(actor, event) {
+  return actor._sendAndAwait(event);
+}
+
+export { sendAndAwait };