@mmapp/react-compiler 0.1.0-alpha.16 → 0.1.0-alpha.17

package/dist/chunk-HOIUP6IF.mjs

@@ -1,690 +0,0 @@
-// src/babel/visitor.ts
-import * as t6 from "@babel/types";
-
-// src/babel/extractors/state-extractor.ts
-import * as t from "@babel/types";
-function inferFieldType(typeAnnotation, defaultValue) {
-  if (typeAnnotation) {
-    if (t.isTSNumberKeyword(typeAnnotation)) return "number";
-    if (t.isTSStringKeyword(typeAnnotation)) return "text";
-    if (t.isTSBooleanKeyword(typeAnnotation)) return "boolean";
-    if (t.isTSTypeReference(typeAnnotation)) {
-      const typeName = t.isIdentifier(typeAnnotation.typeName) ? typeAnnotation.typeName.name : "";
-      if (typeName === "Date") return "date";
-    }
-    if (t.isTSArrayType(typeAnnotation) || t.isTSTypeLiteral(typeAnnotation) || t.isTSTupleType(typeAnnotation)) {
-      return "json";
-    }
-  }
-  if (defaultValue) {
-    if (t.isNumericLiteral(defaultValue)) return "number";
-    if (t.isStringLiteral(defaultValue)) return "text";
-    if (t.isBooleanLiteral(defaultValue)) return "boolean";
-    if (t.isArrayExpression(defaultValue) || t.isObjectExpression(defaultValue)) {
-      return "json";
-    }
-    if (t.isNewExpression(defaultValue) && t.isIdentifier(defaultValue.callee)) {
-      if (defaultValue.callee.name === "Date") return "date";
-    }
-  }
-  return "text";
-}
-function extractDefaultValue(arg) {
-  if (t.isNumericLiteral(arg)) return arg.value;
-  if (t.isStringLiteral(arg)) return arg.value;
-  if (t.isBooleanLiteral(arg)) return arg.value;
-  if (t.isNullLiteral(arg)) return null;
-  if (t.isArrayExpression(arg)) {
-    return arg.elements.map(
-      (el) => el && t.isExpression(el) ? extractDefaultValue(el) : null
-    );
-  }
-  if (t.isObjectExpression(arg)) {
-    const obj = {};
-    arg.properties.forEach((prop) => {
-      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isExpression(prop.value)) {
-        obj[prop.key.name] = extractDefaultValue(prop.value);
-      }
-    });
-    return obj;
-  }
-  return void 0;
-}
-function extractStates(path, state) {
-  const parent = path.parentPath;
-  if (!parent.isVariableDeclarator()) return;
-  const id = parent.node.id;
-  if (!t.isArrayPattern(id) || id.elements.length < 1) return;
-  const firstElement = id.elements[0];
-  if (!t.isIdentifier(firstElement)) return;
-  const fieldName = firstElement.name;
-  const args = path.node.arguments;
-  const defaultValue = args.length > 0 && t.isExpression(args[0]) ? args[0] : null;
-  let typeAnnotation = null;
-  if (path.node.typeParameters && t.isTSTypeParameterInstantiation(path.node.typeParameters)) {
-    const params = path.node.typeParameters.params;
-    if (params.length > 0) {
-      typeAnnotation = params[0];
-    }
-  }
-  const fieldType = inferFieldType(typeAnnotation, defaultValue);
-  const fieldDefaultValue = defaultValue ? extractDefaultValue(defaultValue) : void 0;
-  const field = {
-    name: fieldName,
-    type: fieldType,
-    default_value: fieldDefaultValue
-  };
-  const compilerState = state;
-  if (!compilerState.fields) compilerState.fields = [];
-  if (!compilerState.fields.some((f) => f.name === fieldName)) {
-    compilerState.fields.push(field);
-  }
-}
-
-// src/babel/extractors/effect-extractor.ts
-import * as t2 from "@babel/types";
-function analyzeCallbackBody(body, actionCounter) {
-  const actions = [];
-  for (const statement of body) {
-    if (t2.isExpressionStatement(statement)) {
-      const expr = statement.expression;
-      if (t2.isCallExpression(expr) && t2.isIdentifier(expr.callee)) {
-        const calleeName = expr.callee.name;
-        const args = expr.arguments;
-        if (calleeName === "setField" && args.length >= 2) {
-          const field = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
-          const arg1 = args[1];
-          if (field !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
-            const value = extractValue(arg1);
-            actions.push({
-              id: `auto_${++actionCounter.value}`,
-              type: "set_field",
-              mode: "auto",
-              config: { field, value }
-            });
-          }
-        } else if (calleeName === "setMemory" && args.length >= 2) {
-          const key = t2.isStringLiteral(args[0]) ? args[0].value : void 0;
-          const arg1 = args[1];
-          if (key !== void 0 && !t2.isArgumentPlaceholder(arg1)) {
-            const value = extractValue(arg1);
-            actions.push({
-              id: `auto_${++actionCounter.value}`,
-              type: "set_memory",
-              mode: "auto",
-              config: { key, value }
-            });
-          }
-        } else if (calleeName.startsWith("set") && args.length >= 1) {
-          const fieldName = calleeName.slice(3).charAt(0).toLowerCase() + calleeName.slice(4);
-          const arg0 = args[0];
-          if (!t2.isArgumentPlaceholder(arg0)) {
-            const value = extractValue(arg0);
-            actions.push({
-              id: `auto_${++actionCounter.value}`,
-              type: "set_field",
-              mode: "auto",
-              config: { field: fieldName, value }
-            });
-          }
-        }
-      } else if (t2.isCallExpression(expr)) {
-        const callee = expr.callee;
-        const args = expr.arguments;
-        if (t2.isMemberExpression(callee) && t2.isIdentifier(callee.object) && callee.object.name === "console" && t2.isIdentifier(callee.property) && callee.property.name === "log" && args.length > 0) {
-          const arg0 = args[0];
-          if (!t2.isArgumentPlaceholder(arg0)) {
-            const message = extractValue(arg0);
-            actions.push({
-              id: `auto_${++actionCounter.value}`,
-              type: "log_event",
-              mode: "auto",
-              config: { message }
-            });
-          }
-        } else {
-          actions.push({
-            id: `auto_${++actionCounter.value}`,
-            type: "custom",
-            mode: "auto",
-            config: { expression: generateCode(expr) }
-          });
-        }
-      }
-    }
-  }
-  return actions;
-}
-function extractValue(node) {
-  if (t2.isNumericLiteral(node)) return node.value;
-  if (t2.isStringLiteral(node)) return node.value;
-  if (t2.isBooleanLiteral(node)) return node.value;
-  if (t2.isNullLiteral(node)) return null;
-  if (t2.isArrayExpression(node)) {
-    return node.elements.map((el) => el && t2.isExpression(el) ? extractValue(el) : null);
-  }
-  if (t2.isObjectExpression(node)) {
-    const obj = {};
-    node.properties.forEach((prop) => {
-      if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && t2.isExpression(prop.value)) {
-        obj[prop.key.name] = extractValue(prop.value);
-      }
-    });
-    return obj;
-  }
-  return generateCode(node);
-}
-function generateCode(node) {
-  if (t2.isIdentifier(node)) return node.name;
-  if (t2.isNumericLiteral(node)) return String(node.value);
-  if (t2.isStringLiteral(node)) return `"${node.value}"`;
-  if (t2.isBooleanLiteral(node)) return String(node.value);
-  if (t2.isNullLiteral(node)) return "null";
-  return "[Expression]";
-}
-function ensureState(states, stateName) {
-  if (!states.has(stateName)) {
-    states.set(stateName, {
-      name: stateName,
-      type: "REGULAR",
-      on_enter: [],
-      during: [],
-      on_exit: []
-    });
-  }
-  return states.get(stateName);
-}
-function extractEffects(path, state) {
-  const callee = path.node.callee;
-  if (!t2.isIdentifier(callee)) return;
-  const hookName = callee.name;
-  const args = path.node.arguments;
-  if ((hookName === "useOnEnter" || hookName === "useOnExit") && args.length >= 2) {
-    const stateArg = args[0];
-    const callbackArg = args[1];
-    if (!t2.isStringLiteral(stateArg)) return;
-    const stateName = stateArg.value;
-    let callbackBody = [];
-    if (t2.isArrowFunctionExpression(callbackArg) || t2.isFunctionExpression(callbackArg)) {
-      const body = callbackArg.body;
-      if (t2.isBlockStatement(body)) {
-        callbackBody = body.body;
-      } else if (t2.isExpression(body)) {
-        callbackBody = [t2.expressionStatement(body)];
-      }
-    }
-    const compilerState = state;
-    if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
-    if (!compilerState.actionCounter) compilerState.actionCounter = 0;
-    const stateDefinition = ensureState(compilerState.states, stateName);
-    const actions = analyzeCallbackBody(callbackBody, { value: compilerState.actionCounter });
-    compilerState.actionCounter += actions.length;
-    if (hookName === "useOnEnter") {
-      stateDefinition.on_enter.push(...actions);
-    } else if (hookName === "useOnExit") {
-      stateDefinition.on_exit.push(...actions);
-    }
-  }
-}
-
-// src/babel/extractors/transition-extractor.ts
-import * as t3 from "@babel/types";
-function extractTransitions(path, state) {
-  const callee = path.node.callee;
-  if (!t3.isIdentifier(callee) || callee.name !== "useTransition") return;
-  const args = path.node.arguments;
-  if (args.length < 1) return;
-  const nameArg = args[0];
-  if (!t3.isStringLiteral(nameArg)) return;
-  const transitionName = nameArg.value;
-  const compilerState = state;
-  if (!compilerState.transitions) compilerState.transitions = [];
-  const existing = compilerState.transitions.find((t7) => t7.name === transitionName);
-  if (existing) return;
-  const transition = {
-    name: transitionName,
-    from: [],
-    to: "",
-    actions: [],
-    conditions: []
-  };
-  compilerState.transitions.push(transition);
-}
-function inferTransitionStates(transitions, states) {
-  const stateArray = Array.from(states.values());
-  const startStates = stateArray.filter((s) => s.type === "START");
-  const regularStates = stateArray.filter((s) => s.type === "REGULAR");
-  if (startStates.length === 1 && regularStates.length > 0) {
-    transitions.forEach((t7, idx) => {
-      if (t7.from.length === 0) {
-        t7.from = [startStates[0].name];
-      }
-      if (!t7.to) {
-        t7.to = regularStates[idx % regularStates.length]?.name || "draft";
-      }
-    });
-  } else {
-    const allStateNames = stateArray.map((s) => s.name);
-    transitions.forEach((t7, idx) => {
-      if (t7.from.length === 0 && allStateNames.length > 0) {
-        t7.from = [allStateNames[0]];
-      }
-      if (!t7.to && allStateNames.length > 1) {
-        t7.to = allStateNames[Math.min(idx + 1, allStateNames.length - 1)];
-      }
-    });
-  }
-}
-
-// src/babel/extractors/event-extractor.ts
-import * as t4 from "@babel/types";
-function analyzeEventCallback(body) {
-  const actions = [];
-  for (const statement of body) {
-    if (t4.isExpressionStatement(statement)) {
-      const expr = statement.expression;
-      if (t4.isCallExpression(expr) && t4.isIdentifier(expr.callee)) {
-        const calleeName = expr.callee.name;
-        const args = expr.arguments;
-        if (calleeName === "setField" && args.length >= 2) {
-          const field = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
-          const expression = generateExpression(args[1]);
-          if (field) {
-            actions.push({
-              type: "set_field",
-              field,
-              expression
-            });
-          }
-        } else if (calleeName === "setMemory" && args.length >= 2) {
-          const key = t4.isStringLiteral(args[0]) ? args[0].value : void 0;
-          const expression = generateExpression(args[1]);
-          if (key) {
-            actions.push({
-              type: "set_memory",
-              key,
-              expression
-            });
-          }
-        }
-      } else if (t4.isCallExpression(expr)) {
-        const callee = expr.callee;
-        const args = expr.arguments;
-        if (t4.isMemberExpression(callee) && t4.isIdentifier(callee.object) && callee.object.name === "console" && t4.isIdentifier(callee.property) && callee.property.name === "log") {
-          const message = args.length > 0 ? generateExpression(args[0]) : "";
-          actions.push({
-            type: "log_event",
-            message
-          });
-        }
-      }
-    }
-  }
-  return actions;
-}
-function generateExpression(node) {
-  if (t4.isStringLiteral(node)) return node.value;
-  if (t4.isNumericLiteral(node)) return String(node.value);
-  if (t4.isBooleanLiteral(node)) return String(node.value);
-  if (t4.isIdentifier(node)) return node.name;
-  if (t4.isBinaryExpression(node)) {
-    return `${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)}`;
-  }
-  if (t4.isCallExpression(node) && t4.isIdentifier(node.callee)) {
-    const args = node.arguments.map((arg) => generateExpression(arg)).join(", ");
-    return `${node.callee.name}(${args})`;
-  }
-  return "[Expression]";
-}
-function ensureState2(states, stateName) {
-  if (!states.has(stateName)) {
-    states.set(stateName, {
-      name: stateName,
-      type: "REGULAR",
-      on_enter: [],
-      during: [],
-      on_exit: []
-    });
-  }
-  return states.get(stateName);
-}
-function extractEvents(path, state) {
-  const callee = path.node.callee;
-  if (!t4.isIdentifier(callee) || callee.name !== "useOnEvent") return;
-  const args = path.node.arguments;
-  if (args.length < 2) return;
-  const patternArg = args[0];
-  const callbackArg = args[1];
-  const optionsArg = args.length > 2 ? args[2] : null;
-  if (!t4.isStringLiteral(patternArg)) return;
-  const pattern = patternArg.value;
-  let callbackBody = [];
-  if (t4.isArrowFunctionExpression(callbackArg) || t4.isFunctionExpression(callbackArg)) {
-    const body = callbackArg.body;
-    if (t4.isBlockStatement(body)) {
-      callbackBody = body.body;
-    } else if (t4.isExpression(body)) {
-      callbackBody = [t4.expressionStatement(body)];
-    }
-  }
-  let stateName = null;
-  if (optionsArg && t4.isObjectExpression(optionsArg)) {
-    const whileProp = optionsArg.properties.find(
-      (prop) => t4.isObjectProperty(prop) && t4.isIdentifier(prop.key) && prop.key.name === "while"
-    );
-    if (whileProp && t4.isObjectProperty(whileProp) && t4.isStringLiteral(whileProp.value)) {
-      stateName = whileProp.value.value;
-    }
-  }
-  const actions = analyzeEventCallback(callbackBody);
-  const subscription = {
-    match: pattern,
-    conditions: [],
-    actions
-  };
-  const compilerState = state;
-  if (!compilerState.states) compilerState.states = /* @__PURE__ */ new Map();
-  if (stateName) {
-    const stateDefinition = ensureState2(compilerState.states, stateName);
-    if (!stateDefinition.on_event) stateDefinition.on_event = [];
-    stateDefinition.on_event.push(subscription);
-  } else {
-    if (!compilerState.events) compilerState.events = [];
-    compilerState.events.push(subscription);
-  }
-}
-
-// src/babel/extractors/component-extractor.ts
-import * as t5 from "@babel/types";
-var nodeIdCounter = 0;
-function jsxToExperienceNode(node) {
-  if (t5.isJSXFragment(node)) {
-    return {
-      id: `fragment_${++nodeIdCounter}`,
-      children: node.children.map(jsxChildToNode).filter(Boolean)
-    };
-  }
-  const element = node.openingElement;
-  const componentName = t5.isJSXIdentifier(element.name) ? element.name.name : "div";
-  const id = generateNodeId(componentName);
-  const config = {};
-  const bindings = {};
-  let visibleWhen;
-  for (const attr of element.attributes) {
-    if (t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name)) {
-      const attrName = attr.name.name;
-      const attrValue = attr.value;
-      if (attrName === "visible_when" && t5.isStringLiteral(attrValue)) {
-        visibleWhen = attrValue.value;
-      } else if (attrName === "data-slot" && t5.isStringLiteral(attrValue)) {
-        config.slot = attrValue.value;
-      } else if (t5.isJSXExpressionContainer(attrValue)) {
-        const expr = attrValue.expression;
-        if (t5.isIdentifier(expr)) {
-          bindings[attrName] = `$instance.${expr.name}`;
-        } else if (t5.isExpression(expr)) {
-          bindings[attrName] = generateExpression2(expr);
-        }
-      } else if (t5.isStringLiteral(attrValue)) {
-        config[attrName] = attrValue.value;
-      }
-    }
-  }
-  const children = node.children.map(jsxChildToNode).filter(Boolean);
-  const experienceNode = {
-    id,
-    component: componentName,
-    ...Object.keys(bindings).length > 0 && { bindings },
-    ...Object.keys(config).length > 0 && { config },
-    ...visibleWhen && { visible_when: visibleWhen },
-    ...children.length > 0 && { children }
-  };
-  return experienceNode;
-}
-function jsxChildToNode(child) {
-  if (t5.isJSXElement(child)) {
-    return jsxToExperienceNode(child);
-  }
-  if (t5.isJSXFragment(child)) {
-    return jsxToExperienceNode(child);
-  }
-  return null;
-}
-function generateNodeId(componentName) {
-  const id = componentName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-  return `${id}_${++nodeIdCounter}`;
-}
-function generateExpression2(node) {
-  if (t5.isIdentifier(node)) return node.name;
-  if (t5.isStringLiteral(node)) return node.value;
-  if (t5.isNumericLiteral(node)) return String(node.value);
-  if (t5.isBooleanLiteral(node)) return String(node.value);
-  if (t5.isMemberExpression(node)) {
-    const obj = generateExpression2(node.object);
-    const prop = t5.isIdentifier(node.property) ? node.property.name : "[property]";
-    return `${obj}.${prop}`;
-  }
-  return "[Expression]";
-}
-function extractComponents(path, state) {
-  const arg = path.node.argument;
-  if (!arg) return;
-  let experienceNode = null;
-  if (t5.isJSXElement(arg)) {
-    experienceNode = jsxToExperienceNode(arg);
-  } else if (t5.isJSXFragment(arg)) {
-    experienceNode = jsxToExperienceNode(arg);
-  }
-  if (experienceNode) {
-    const compilerState = state;
-    compilerState.experience = experienceNode;
-  }
-}
-
-// src/babel/emitters/pure-form-emitter.ts
-function emitPureForm(extracted) {
-  const { slug, name, version, description, category, fields, states, transitions } = extracted;
-  const stateArray = Array.from(states.values());
-  if (stateArray.length === 0) {
-    stateArray.push({
-      name: "draft",
-      type: "START",
-      on_enter: [],
-      during: [],
-      on_exit: []
-    });
-  } else {
-    const hasStart = stateArray.some((s) => s.type === "START");
-    if (!hasStart && stateArray.length > 0) {
-      stateArray[0].type = "START";
-    }
-  }
-  inferTransitionStates(transitions, states);
-  const stateNames = new Set(stateArray.map((s) => s.name));
-  for (const transition of transitions) {
-    if (!stateNames.has(transition.to)) {
-      stateArray.push({
-        name: transition.to,
-        type: "REGULAR",
-        on_enter: [],
-        during: [],
-        on_exit: []
-      });
-      stateNames.add(transition.to);
-    }
-  }
-  return {
-    slug,
-    name,
-    version,
-    description,
-    category,
-    fields,
-    states: stateArray,
-    transitions,
-    roles: [],
-    tags: [],
-    metadata: extracted.experience ? { experience: extracted.experience } : {}
-  };
-}
-function compilerStateToWorkflow(state, metadata) {
-  return {
-    slug: metadata.slug || "workflow",
-    name: metadata.name || "Workflow",
-    version: metadata.version || "0.1.0",
-    description: metadata.description,
-    category: metadata.category || "workflow",
-    fields: state.fields || [],
-    states: state.states || /* @__PURE__ */ new Map(),
-    transitions: state.transitions || [],
-    events: state.events || [],
-    experience: state.experience
-  };
-}
-
-// src/babel/visitor.ts
-function createVisitor(_options = {}) {
-  return {
-    Program: {
-      // Initialize compiler state at program entry
-      enter(_path, state) {
-        const compilerState = {
-          fields: [],
-          states: /* @__PURE__ */ new Map(),
-          transitions: [],
-          events: [],
-          actionCounter: 0,
-          metadata: {}
-        };
-        const extractMetadataFromComments = (comments) => {
-          for (const comment of comments) {
-            if (comment.type === "CommentBlock") {
-              const lines = comment.value.split("\n");
-              for (const line of lines) {
-                const match = line.match(/@(\w+)\s+(.+)/);
-                if (match) {
-                  const [, tag, value] = match;
-                  if (tag === "workflow") compilerState.metadata.slug = value.trim();
-                  if (tag === "version") compilerState.metadata.version = value.trim();
-                  if (tag === "category") compilerState.metadata.category = value.trim();
-                  if (tag === "description") compilerState.metadata.description = value.trim();
-                }
-              }
-            }
-          }
-        };
-        const program = _path.node;
-        const leadingComments = program.leadingComments || [];
-        extractMetadataFromComments(leadingComments);
-        const exportDeclaration = program.body.find(
-          (node) => t6.isExportNamedDeclaration(node) || t6.isExportDefaultDeclaration(node)
-        );
-        if (exportDeclaration) {
-          if (t6.isExportNamedDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t6.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments);
-              }
-            }
-          } else if (t6.isExportDefaultDeclaration(exportDeclaration)) {
-            const declaration = exportDeclaration.declaration;
-            if (t6.isFunctionDeclaration(declaration)) {
-              if (declaration.id) {
-                compilerState.metadata.name = declaration.id.name;
-              }
-              if (declaration.leadingComments) {
-                extractMetadataFromComments(declaration.leadingComments);
-              }
-            } else if (t6.isIdentifier(declaration)) {
-              compilerState.metadata.name = declaration.name;
-            }
-          }
-        }
-        if (!compilerState.metadata.slug && state.filename) {
-          const fileName = state.filename.split("/").pop() || "";
-          compilerState.metadata.slug = fileName.replace(/\.workflow\.(tsx?|jsx?)$/, "").replace(/\.(tsx?|jsx?)$/, "").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-        }
-        Object.assign(state, compilerState);
-      },
-      // After all extraction, emit Pure Form JSON
-      exit(_path, state) {
-        const compilerState = state;
-        const extracted = compilerStateToWorkflow(compilerState, compilerState.metadata);
-        const ir = emitPureForm(extracted);
-        if (!state.file.metadata) state.file.metadata = {};
-        state.file.metadata.mindmatrixIR = ir;
-      }
-    },
-    // Extract metadata from function declarations with JSDoc
-    FunctionDeclaration(path, state) {
-      const comments = path.node.leadingComments || [];
-      const compilerState = state;
-      for (const comment of comments) {
-        if (comment.type === "CommentBlock") {
-          const lines = comment.value.split("\n");
-          for (const line of lines) {
-            const match = line.match(/@(\w+)\s+(.+)/);
-            if (match) {
-              const [, tag, value] = match;
-              if (tag === "workflow") compilerState.metadata.slug = value.trim();
-              if (tag === "version") compilerState.metadata.version = value.trim();
-              if (tag === "category") compilerState.metadata.category = value.trim();
-              if (tag === "description") compilerState.metadata.description = value.trim();
-            }
-          }
-        }
-      }
-    },
-    // Extract useState calls
-    CallExpression(path, state) {
-      const callee = path.node.callee;
-      if (!t6.isIdentifier(callee)) return;
-      switch (callee.name) {
-        case "useState":
-          extractStates(path, state);
-          break;
-        case "useOnEnter":
-        case "useOnExit":
-          extractEffects(path, state);
-          break;
-        case "useTransition":
-          extractTransitions(path, state);
-          break;
-        case "useOnEvent":
-          extractEvents(path, state);
-          break;
-      }
-    },
-    // Extract JSX from function component return
-    ReturnStatement(path, state) {
-      if (t6.isJSXElement(path.node.argument) || t6.isJSXFragment(path.node.argument)) {
-        extractComponents(path, state);
-      }
-    }
-  };
-}
-
-// src/babel/index.ts
-function babelPlugin(api, options = {}) {
-  api.assertVersion(7);
-  return {
-    name: "mindmatrix-react",
-    visitor: createVisitor(options)
-  };
-}
-
-export {
-  extractStates,
-  extractEffects,
-  extractTransitions,
-  extractEvents,
-  extractComponents,
-  emitPureForm,
-  compilerStateToWorkflow,
-  createVisitor,
-  babelPlugin
-};