@mmapp/react-compiler 0.1.0-alpha.1

package/dist/testing/index.mjs

@@ -0,0 +1,247 @@
+import {
+  babelPlugin
+} from "../chunk-HLRGCCIL.mjs";
+import {
+  __require
+} from "../chunk-Y6FXYEAI.mjs";
+
+// src/testing/test-utils.ts
+import { transformSync } from "@babel/core";
+function compileWorkflow(code, options = {}) {
+  const filename = options.filename ?? "test.workflow.tsx";
+  const mode = options.mode ?? "infer";
+  const result = transformSync(code, {
+    filename,
+    plugins: [[babelPlugin, { mode }]],
+    parserOpts: { plugins: ["typescript", "jsx"], attachComment: true }
+  });
+  const ir = result?.metadata?.mindmatrixIR;
+  if (!ir) {
+    throw new Error(
+      `compileWorkflow: no IR produced. Check that the source exports a component or model.
+Source preview: ${code.trim().slice(0, 120)}...`
+    );
+  }
+  return ir;
+}
+function compileModel(code, options = {}) {
+  const filename = options.filename ?? "models/test.ts";
+  const mode = options.mode ?? "infer";
+  const result = transformSync(code, {
+    filename,
+    plugins: [[babelPlugin, { mode }]],
+    parserOpts: { plugins: ["typescript"], attachComment: true }
+  });
+  const ir = result?.metadata?.mindmatrixIR;
+  if (!ir) {
+    throw new Error(
+      `compileModel: no IR produced. Check that the source exports an interface and transitions.
+Source preview: ${code.trim().slice(0, 120)}...`
+    );
+  }
+  return ir;
+}
+function compileServerAction(code, options = {}) {
+  const filename = options.filename ?? "actions.server.ts";
+  return compileWorkflow(code, { ...options, filename });
+}
+function compileRaw(code, options = {}) {
+  const filename = options.filename ?? "test.workflow.tsx";
+  const mode = options.mode ?? "infer";
+  const result = transformSync(code, {
+    filename,
+    plugins: [[babelPlugin, { mode }]],
+    parserOpts: { plugins: ["typescript", "jsx"], attachComment: true }
+  });
+  const metadata = result?.metadata ?? {};
+  return {
+    ir: metadata.mindmatrixIR,
+    code: result?.code ?? null,
+    warnings: metadata.mindmatrixWarnings ?? [],
+    errors: metadata.mindmatrixErrors ?? []
+  };
+}
+function createMockBlueprintContext(props = {}) {
+  const {
+    slug = "test-blueprint",
+    version = "1.0.0",
+    initialState = {},
+    definitions = []
+  } = props;
+  return {
+    slug,
+    version,
+    definitions,
+    activeDefinition: definitions[0] ?? null,
+    instanceState: initialState,
+    dispatch: () => {
+    },
+    navigate: () => {
+    }
+  };
+}
+function createMockWorkflowContext(props = {}) {
+  const {
+    slug = "test-workflow",
+    currentState = "draft",
+    fields = {},
+    transitions = [],
+    onTransition = () => {
+    }
+  } = props;
+  return {
+    slug,
+    currentState,
+    fields,
+    availableTransitions: transitions,
+    transition: onTransition,
+    setField: (name, value) => {
+      fields[name] = value;
+    },
+    getField: (name) => fields[name]
+  };
+}
+function extractFields(code, options) {
+  return compileWorkflow(code, options).fields;
+}
+function extractStates(code, options) {
+  return compileWorkflow(code, options).states;
+}
+function extractTransitions(code, options) {
+  return compileWorkflow(code, options).transitions;
+}
+
+// src/testing/snapshot.ts
+function snapshotIR(code, options) {
+  const ir = options?.filename?.includes("models/") ? compileModel(code, options) : compileWorkflow(code, options);
+  return irToSnapshot(ir);
+}
+function irToSnapshot(ir) {
+  const meta = ir.metadata ?? {};
+  return {
+    slug: ir.slug ?? "",
+    version: ir.version ?? "",
+    category: Array.isArray(ir.category) ? ir.category[0] : ir.category ?? "workflow",
+    fields: ir.fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      ...f.required === false ? { required: false } : {}
+    })),
+    states: ir.states.map((s) => ({
+      name: s.name,
+      type: s.type,
+      enterActions: s.on_enter?.length ?? 0,
+      exitActions: s.on_exit?.length ?? 0
+    })),
+    transitions: ir.transitions.map((t) => ({
+      name: t.name,
+      from: t.from,
+      to: t.to,
+      conditions: t.conditions?.length ?? 0
+    })),
+    hasExperience: !!meta.experience || !!ir.experience,
+    extensionTags: ir.extensions ? Object.keys(ir.extensions) : [],
+    dataSourceCount: Array.isArray(meta.dataSources) ? meta.dataSources.length : 0,
+    mutationTargetCount: Array.isArray(meta.mutationTargets) ? meta.mutationTargets.length : 0,
+    errorCount: Array.isArray(meta.errors) ? meta.errors.length : 0
+  };
+}
+function installIRMatchers() {
+  try {
+    const { expect } = __require("vitest");
+    expect.extend({
+      toMatchIR(received, expected) {
+        const failures = [];
+        if (expected.slug !== void 0 && received.slug !== expected.slug) {
+          failures.push(`slug: expected "${expected.slug}", got "${received.slug}"`);
+        }
+        if (expected.version !== void 0 && received.version !== expected.version) {
+          failures.push(`version: expected "${expected.version}", got "${received.version}"`);
+        }
+        if (expected.category !== void 0 && received.category !== expected.category) {
+          failures.push(`category: expected "${expected.category}", got "${received.category}"`);
+        }
+        if (expected.description !== void 0 && received.description !== expected.description) {
+          failures.push(`description: expected "${expected.description}", got "${received.description}"`);
+        }
+        if (expected.fields !== void 0) {
+          const expectedFields = expected.fields;
+          for (const exp of expectedFields) {
+            const match = received.fields.find((f) => f.name === exp.name);
+            if (!match) {
+              failures.push(`fields: expected field "${exp.name}" not found`);
+            } else {
+              const matchRec = match;
+              for (const [key, val] of Object.entries(exp)) {
+                if (matchRec[key] !== val) {
+                  failures.push(`fields.${exp.name}.${key}: expected ${JSON.stringify(val)}, got ${JSON.stringify(matchRec[key])}`);
+                }
+              }
+            }
+          }
+        }
+        if (expected.states !== void 0 && Array.isArray(expected.states)) {
+          const expectedStates = expected.states;
+          for (const exp of expectedStates) {
+            const match = received.states.find((s) => s.name === exp.name);
+            if (!match) {
+              failures.push(`states: expected state "${exp.name}" not found`);
+            } else {
+              const matchRec = match;
+              for (const [key, val] of Object.entries(exp)) {
+                if (key === "on_enter" || key === "on_exit" || key === "during") {
+                  const arr = matchRec[key];
+                  if (typeof val === "number" && (arr?.length ?? 0) !== val) {
+                    failures.push(`states.${exp.name}.${key}: expected length ${val}, got ${arr?.length ?? 0}`);
+                  }
+                } else if (matchRec[key] !== val) {
+                  failures.push(`states.${exp.name}.${key}: expected ${JSON.stringify(val)}, got ${JSON.stringify(matchRec[key])}`);
+                }
+              }
+            }
+          }
+        }
+        if (expected.transitions !== void 0 && Array.isArray(expected.transitions)) {
+          const expectedTransitions = expected.transitions;
+          for (const exp of expectedTransitions) {
+            const match = received.transitions.find((t) => t.name === exp.name);
+            if (!match) {
+              failures.push(`transitions: expected transition "${exp.name}" not found`);
+            } else {
+              if (exp.from !== void 0) {
+                const fromMatch = JSON.stringify(match.from) === JSON.stringify(exp.from);
+                if (!fromMatch) {
+                  failures.push(`transitions.${exp.name}.from: expected ${JSON.stringify(exp.from)}, got ${JSON.stringify(match.from)}`);
+                }
+              }
+              if (exp.to !== void 0 && match.to !== exp.to) {
+                failures.push(`transitions.${exp.name}.to: expected "${exp.to}", got "${match.to}"`);
+              }
+            }
+          }
+        }
+        const pass = failures.length === 0;
+        return {
+          pass,
+          message: () => pass ? `expected IR not to match, but it did` : `IR mismatch:
+${failures.map((f) => `  - ${f}`).join("\n")}`
+        };
+      }
+    });
+  } catch {
+  }
+}
+export {
+  compileModel,
+  compileRaw,
+  compileServerAction,
+  compileWorkflow,
+  createMockBlueprintContext,
+  createMockWorkflowContext,
+  extractFields,
+  extractStates,
+  extractTransitions,
+  installIRMatchers,
+  irToSnapshot,
+  snapshotIR
+};

package/dist/vite/index.d.mts

@@ -0,0 +1,59 @@
+import { Plugin } from 'vite';
+
+/**
+ * Vite Plugin — integrates the MindMatrix Babel compiler into the Vite build pipeline.
+ *
+ * Transforms `.workflow.tsx` files through the Babel plugin to extract workflow
+ * IR (fields, states, transitions, experience tree) and emit:
+ *   1. Transformed React code (standard JSX, runs in browser)
+ *   2. `.workflow.json` sidecar files (IR for mm-engine consumption)
+ *
+ * Supports HMR: re-compiles on save, optionally seeds definitions to the dev API.
+ *
+ * Usage:
+ *   // vite.config.ts
+ *   import { mindmatrixReact } from '@mindmatrix/react-compiler/vite';
+ *
+ *   export default defineConfig({
+ *     plugins: [
+ *       mindmatrixReact({
+ *         mode: 'infer',
+ *         include: ['**\/*.workflow.tsx'],
+ *         seedOnCompile: true,
+ *         apiUrl: 'http://localhost:4200/api/v1',
+ *       })
+ *     ]
+ *   });
+ */
+
+interface MindMatrixReactOptions {
+    /** Compilation mode: 'strict' validates imports, 'infer' is permissive. Default: 'infer' */
+    mode?: 'strict' | 'infer';
+    /** Glob patterns for files to compile. Default: ['**\/*.workflow.tsx'] */
+    include?: string[];
+    /** Output directory for .workflow.json sidecar files. Default: 'dist/workflows' */
+    outDir?: string;
+    /** When true, POST compiled definitions to the dev API on each compile. Default: false */
+    seedOnCompile?: boolean;
+    /** Dev API base URL for seeding. Default: 'http://localhost:4200/api/v1' */
+    apiUrl?: string;
+    /** Auth token for dev API seeding. Default: reads from MINDMATRIX_TOKEN env var */
+    authToken?: string;
+    /**
+     * Source map configuration for .workflow.tsx files.
+     * - true: Generate source maps with original source embedded (default in dev)
+     * - false: No source maps
+     * - 'inline': Inline source maps in compiled output
+     * Default: auto-detected from Vite mode (true in dev, false in build)
+     */
+    sourceMaps?: boolean | 'inline';
+    /**
+     * Embed __source metadata on IR nodes (file, line, column).
+     * Enables: compilation error mapping, IR inspector, runtime error traces.
+     * Default: true in dev, false in production.
+     */
+    sourceAnnotations?: boolean;
+}
+declare function mindmatrixReact(options?: MindMatrixReactOptions): Plugin;
+
+export { type MindMatrixReactOptions, mindmatrixReact };

package/dist/vite/index.d.ts

@@ -0,0 +1,59 @@
+import { Plugin } from 'vite';
+
+/**
+ * Vite Plugin — integrates the MindMatrix Babel compiler into the Vite build pipeline.
+ *
+ * Transforms `.workflow.tsx` files through the Babel plugin to extract workflow
+ * IR (fields, states, transitions, experience tree) and emit:
+ *   1. Transformed React code (standard JSX, runs in browser)
+ *   2. `.workflow.json` sidecar files (IR for mm-engine consumption)
+ *
+ * Supports HMR: re-compiles on save, optionally seeds definitions to the dev API.
+ *
+ * Usage:
+ *   // vite.config.ts
+ *   import { mindmatrixReact } from '@mindmatrix/react-compiler/vite';
+ *
+ *   export default defineConfig({
+ *     plugins: [
+ *       mindmatrixReact({
+ *         mode: 'infer',
+ *         include: ['**\/*.workflow.tsx'],
+ *         seedOnCompile: true,
+ *         apiUrl: 'http://localhost:4200/api/v1',
+ *       })
+ *     ]
+ *   });
+ */
+
+interface MindMatrixReactOptions {
+    /** Compilation mode: 'strict' validates imports, 'infer' is permissive. Default: 'infer' */
+    mode?: 'strict' | 'infer';
+    /** Glob patterns for files to compile. Default: ['**\/*.workflow.tsx'] */
+    include?: string[];
+    /** Output directory for .workflow.json sidecar files. Default: 'dist/workflows' */
+    outDir?: string;
+    /** When true, POST compiled definitions to the dev API on each compile. Default: false */
+    seedOnCompile?: boolean;
+    /** Dev API base URL for seeding. Default: 'http://localhost:4200/api/v1' */
+    apiUrl?: string;
+    /** Auth token for dev API seeding. Default: reads from MINDMATRIX_TOKEN env var */
+    authToken?: string;
+    /**
+     * Source map configuration for .workflow.tsx files.
+     * - true: Generate source maps with original source embedded (default in dev)
+     * - false: No source maps
+     * - 'inline': Inline source maps in compiled output
+     * Default: auto-detected from Vite mode (true in dev, false in build)
+     */
+    sourceMaps?: boolean | 'inline';
+    /**
+     * Embed __source metadata on IR nodes (file, line, column).
+     * Enables: compilation error mapping, IR inspector, runtime error traces.
+     * Default: true in dev, false in production.
+     */
+    sourceAnnotations?: boolean;
+}
+declare function mindmatrixReact(options?: MindMatrixReactOptions): Plugin;
+
+export { type MindMatrixReactOptions, mindmatrixReact };