@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/babel/emitters/runtime-glue-emitter.ts

@@ -1,39 +0,0 @@
-/**
- * Runtime Glue Emitter — for infer mode, emits residual React code that imports
- * from @mindmatrix/react and wires up the runtime.
- *
- * This is a placeholder for now — in strict mode, all hooks are removed.
- * In infer mode, we keep the original code and inject runtime wiring.
- */
-
-import * as t from '@babel/types';
-
-/**
- * Wraps the component in WorkflowProvider (infer mode).
- */
-export function emitRuntimeGlue(
-  _path: any,
-  _workflowDefinition: any
-): void {
-  // For now, we keep the original code as-is
-  // In a full implementation, we would:
-  // 1. Import { WorkflowProvider, useWorkflow } from '@mindmatrix/react'
-  // 2. Wrap the component return with <WorkflowProvider definition={...}>
-  // 3. Replace hook calls with runtime bindings
-
-  // This is a simplified version that doesn't modify the code
-  // The IR JSON is emitted separately as a sidecar file
-}
-
-/**
- * Generates import statement for runtime.
- */
-export function generateRuntimeImports(): t.ImportDeclaration {
-  return t.importDeclaration(
-    [
-      t.importSpecifier(t.identifier('WorkflowProvider'), t.identifier('WorkflowProvider')),
-      t.importSpecifier(t.identifier('useWorkflow'), t.identifier('useWorkflow')),
-    ],
-    t.stringLiteral('@mindmatrix/react')
-  );
-}

package/src/babel/extractors/change-extractor.ts

@@ -1,199 +0,0 @@
-/**
- * Change Extractor — extracts useOnChange calls and converts them to field watcher metadata.
- *
- * INPUT:
- *   useOnChange('status', (newVal, oldVal) => {
- *     console.log(`Status changed from ${oldVal} to ${newVal}`);
- *   });
- *
- * OUTPUT (stored in compilerState metadata.fieldWatchers[]):
- *   {
- *     id: "watcher_1",
- *     field: "status",
- *     actions: [{ id: "auto_N", type: "log_event", mode: "auto", config: { message: "..." } }]
- *   }
- */
-
-import type { NodePath } from '@babel/traverse';
-import * as t from '@babel/types';
-import type { IRActionDefinition } from '@mindmatrix/player-core';
-import type { CompilerState } from '../../types';
-
-export interface FieldWatcher {
-  id: string;
-  field: string;
-  actions: IRActionDefinition[];
-}
-
-let watcherIdCounter = 0;
-
-/**
- * Resets the watcher ID counter. Call between file compilations.
- */
-export function resetWatcherIdCounter(): void {
-  watcherIdCounter = 0;
-}
-
-/**
- * Analyzes a callback body and extracts action definitions.
- */
-function analyzeCallbackBody(
-  body: t.Statement[],
-  actionCounter: { value: number }
-): IRActionDefinition[] {
-  const actions: IRActionDefinition[] = [];
-
-  for (const statement of body) {
-    if (!t.isExpressionStatement(statement)) continue;
-    const expr = statement.expression;
-
-    if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
-      const calleeName = expr.callee.name;
-      const args = expr.arguments;
-
-      if (calleeName === 'setField' && args.length >= 2) {
-        const field = t.isStringLiteral(args[0]) ? args[0].value : undefined;
-        if (field !== undefined) {
-          actions.push({
-            id: `auto_${++actionCounter.value}`,
-            type: 'set_field',
-            mode: 'auto',
-            config: { field, value: extractValue(args[1]) },
-          });
-        }
-      } else if (calleeName === 'setMemory' && args.length >= 2) {
-        const key = t.isStringLiteral(args[0]) ? args[0].value : undefined;
-        if (key !== undefined) {
-          actions.push({
-            id: `auto_${++actionCounter.value}`,
-            type: 'set_memory',
-            mode: 'auto',
-            config: { key, value: extractValue(args[1]) },
-          });
-        }
-      } else if (calleeName.startsWith('set') && calleeName.length > 3 && args.length >= 1) {
-        const fieldName = calleeName.slice(3, 4).toLowerCase() + calleeName.slice(4);
-        actions.push({
-          id: `auto_${++actionCounter.value}`,
-          type: 'set_field',
-          mode: 'auto',
-          config: { field: fieldName, value: extractValue(args[0]) },
-        });
-      }
-    } else if (t.isCallExpression(expr)) {
-      const callee = expr.callee;
-      if (
-        t.isMemberExpression(callee) &&
-        t.isIdentifier(callee.object) &&
-        callee.object.name === 'console' &&
-        t.isIdentifier(callee.property) &&
-        callee.property.name === 'log' &&
-        expr.arguments.length > 0
-      ) {
-        actions.push({
-          id: `auto_${++actionCounter.value}`,
-          type: 'log_event',
-          mode: 'auto',
-          config: { message: extractValue(expr.arguments[0]) },
-        });
-      }
-    }
-  }
-
-  return actions;
-}
-
-function extractValue(node: t.Node): unknown {
-  if (t.isNumericLiteral(node)) return node.value;
-  if (t.isStringLiteral(node)) return node.value;
-  if (t.isBooleanLiteral(node)) return node.value;
-  if (t.isNullLiteral(node)) return null;
-  if (t.isIdentifier(node)) return node.name;
-  if (t.isTemplateLiteral(node)) {
-    return node.quasis.map((q, i) => {
-      const raw = q.value.raw;
-      if (i < (node as t.TemplateLiteral).expressions.length) {
-        const expr = (node as t.TemplateLiteral).expressions[i];
-        return raw + '${' + (t.isIdentifier(expr) ? expr.name : '[expr]') + '}';
-      }
-      return raw;
-    }).join('');
-  }
-  if (t.isArrayExpression(node)) {
-    return node.elements.map((el) => (el && t.isExpression(el) ? extractValue(el) : null));
-  }
-  if (t.isObjectExpression(node)) {
-    const obj: Record<string, unknown> = {};
-    node.properties.forEach((prop) => {
-      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isExpression(prop.value)) {
-        obj[prop.key.name] = extractValue(prop.value);
-      }
-    });
-    return obj;
-  }
-  if (t.isMemberExpression(node)) {
-    const obj = t.isIdentifier(node.object) ? node.object.name : '[object]';
-    const prop = t.isIdentifier(node.property) ? node.property.name : '[property]';
-    return `${obj}.${prop}`;
-  }
-  if (t.isConditionalExpression(node)) {
-    return `(${extractValue(node.test)} ? ${extractValue(node.consequent)} : ${extractValue(node.alternate)})`;
-  }
-  if (t.isBinaryExpression(node)) {
-    return `(${extractValue(node.left)} ${node.operator} ${extractValue(node.right)})`;
-  }
-  if (t.isLogicalExpression(node)) {
-    return `(${extractValue(node.left)} ${node.operator} ${extractValue(node.right)})`;
-  }
-  if (t.isTSAsExpression(node)) return extractValue(node.expression);
-  if (t.isTSNonNullExpression(node)) return extractValue(node.expression);
-  return '[Expression]';
-}
-
-/**
- * Main extractor function called from the visitor.
- *
- * Handles: useOnChange(field, handler)
- */
-export function extractChangeWatcher(path: NodePath<t.CallExpression>, state: any): void {
-  const callee = path.node.callee;
-  if (!t.isIdentifier(callee) || callee.name !== 'useOnChange') return;
-
-  const args = path.node.arguments;
-  if (args.length < 2) return;
-
-  const fieldArg = args[0];
-  const callbackArg = args[1];
-
-  if (!t.isStringLiteral(fieldArg)) return;
-  const field = fieldArg.value;
-
-  // Extract callback body
-  let callbackBody: t.Statement[] = [];
-  if (t.isArrowFunctionExpression(callbackArg) || t.isFunctionExpression(callbackArg)) {
-    const body = callbackArg.body;
-    if (t.isBlockStatement(body)) {
-      callbackBody = body.body;
-    } else if (t.isExpression(body)) {
-      callbackBody = [t.expressionStatement(body)];
-    }
-  }
-
-  const compilerState = state as CompilerState;
-  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
-
-  const actions = analyzeCallbackBody(callbackBody, { value: compilerState.actionCounter });
-  compilerState.actionCounter += actions.length;
-
-  const watcher: FieldWatcher = {
-    id: `watcher_${++watcherIdCounter}`,
-    field,
-    actions,
-  };
-
-  // Store in compiler state metadata
-  if (!compilerState.metadata) compilerState.metadata = {};
-  const meta = compilerState.metadata as Record<string, unknown>;
-  if (!meta.fieldWatchers) meta.fieldWatchers = [];
-  (meta.fieldWatchers as FieldWatcher[]).push(watcher);
-}