@mmapp/react-compiler 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/babel/index.js

@@ -5993,8 +5993,12 @@ function extractStaticObj(obj) {
   return result;
 }
 
-// src/babel/emitters/pure-form-emitter.ts
-var import_player_core = require("@mindmatrix/player-core");
+// ../player-core/dist/index.mjs
+function normalizeCategory(primary, ...tags) {
+  const uniqueTags = [...new Set(tags.filter((t22) => t22 !== primary))];
+  uniqueTags.sort();
+  return [primary, ...uniqueTags];
+}
 
 // src/babel/emitters/experience-transform.ts
 function transformToFrontend(node) {
@@ -6387,7 +6391,7 @@ function liftAction(action) {
   }
   return {
     slug: action.id,
-    category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
+    category: normalizeCategory("expression", "mutation", action.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -6417,7 +6421,7 @@ function liftSchedule(during) {
   for (const action of during.actions) {
     parts.push({
       slug: "do",
-      category: (0, import_player_core.normalizeCategory)("expression", "mutation", action.type),
+      category: normalizeCategory("expression", "mutation", action.type),
       parts: Object.entries(action.config || {}).map(([key, value]) => ({
         slug: key,
         category: ["atom"],
@@ -6427,7 +6431,7 @@ function liftSchedule(during) {
   }
   return {
     slug: during.id,
-    category: (0, import_player_core.normalizeCategory)("schedule", during.type),
+    category: normalizeCategory("schedule", during.type),
     parts
   };
 }
@@ -6440,14 +6444,14 @@ function liftState(state) {
   if (state.on_enter && state.on_enter.length > 0) {
     parts.push({
       slug: "on_enter",
-      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
+      category: normalizeCategory("expression", "sequence"),
       parts: state.on_enter.map(liftAction)
     });
   }
   if (state.on_exit && state.on_exit.length > 0) {
     parts.push({
       slug: "on_exit",
-      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
+      category: normalizeCategory("expression", "sequence"),
       parts: state.on_exit.map(liftAction)
     });
   }
@@ -6458,7 +6462,7 @@ function liftState(state) {
   }
   return {
     slug: state.name,
-    category: (0, import_player_core.normalizeCategory)("state", ...tags),
+    category: normalizeCategory("state", ...tags),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -6481,17 +6485,17 @@ function liftTransition(transition) {
   if (transition.actions && transition.actions.length > 0) {
     parts.push({
       slug: "actions",
-      category: (0, import_player_core.normalizeCategory)("expression", "sequence"),
+      category: normalizeCategory("expression", "sequence"),
       parts: transition.actions.map(liftAction)
     });
   }
   if (transition.conditions && transition.conditions.length > 0) {
     parts.push({
       slug: "conditions",
-      category: (0, import_player_core.normalizeCategory)("expression", "guard"),
+      category: normalizeCategory("expression", "guard"),
       parts: transition.conditions.map((c, i) => ({
         slug: `condition_${i}`,
-        category: (0, import_player_core.normalizeCategory)("expression", c.type || "condition"),
+        category: normalizeCategory("expression", c.type || "condition"),
         parts: c.expression ? [{ slug: c.expression, category: ["binding"] }] : void 0
       }))
     });
@@ -6530,7 +6534,7 @@ function liftField(field) {
   }
   return {
     slug: field.name,
-    category: (0, import_player_core.normalizeCategory)("field", field.type),
+    category: normalizeCategory("field", field.type),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -6553,20 +6557,20 @@ function liftView(node) {
         if (match) {
           parts.push({
             slug: key,
-            category: (0, import_player_core.normalizeCategory)("expression", "effect", "transition"),
+            category: normalizeCategory("expression", "effect", "transition"),
             parts: [{ slug: match[1], category: ["ref"] }]
           });
         } else {
           parts.push({
             slug: key,
-            category: (0, import_player_core.normalizeCategory)("expression", "binding"),
+            category: normalizeCategory("expression", "binding"),
             parts: [{ slug: String(expr), category: ["binding"] }]
           });
         }
       } else {
         parts.push({
           slug: key,
-          category: (0, import_player_core.normalizeCategory)("expression", "binding"),
+          category: normalizeCategory("expression", "binding"),
           parts: [{ slug: String(expr), category: ["binding"] }]
         });
       }
@@ -6577,20 +6581,20 @@ function liftView(node) {
     if (eqMatch) {
       parts.push({
         slug: "visible_when",
-        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
+        category: normalizeCategory("expression", "guard"),
         parts: [{
           slug: "body",
-          category: (0, import_player_core.normalizeCategory)("expression", "eq"),
+          category: normalizeCategory("expression", "eq"),
           parts: [
-            { slug: "lhs", category: (0, import_player_core.normalizeCategory)("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
-            { slug: "rhs", category: (0, import_player_core.normalizeCategory)("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
+            { slug: "lhs", category: normalizeCategory("expression", "path"), parts: [{ slug: eqMatch[1], category: ["binding"] }] },
+            { slug: "rhs", category: normalizeCategory("expression", "literal"), parts: [{ slug: eqMatch[2], category: ["literal"] }] }
           ]
         }]
       });
     } else {
       parts.push({
         slug: "visible_when",
-        category: (0, import_player_core.normalizeCategory)("expression", "guard"),
+        category: normalizeCategory("expression", "guard"),
         parts: [{ slug: node.visible_when, category: ["binding"] }]
       });
     }
@@ -6602,7 +6606,7 @@ function liftView(node) {
   }
   return {
     slug: node.id,
-    category: (0, import_player_core.normalizeCategory)("view", componentTag),
+    category: normalizeCategory("view", componentTag),
     parts: parts.length > 0 ? parts : void 0
   };
 }
@@ -6623,7 +6627,7 @@ function emitCanonical(extracted, sourceFilename) {
   }
   parts.push({
     slug: "manifest",
-    category: (0, import_player_core.normalizeCategory)("meta", "manifest"),
+    category: normalizeCategory("meta", "manifest"),
     parts: [
       {
         slug: "workflows",
@@ -6644,7 +6648,7 @@ function emitCanonical(extracted, sourceFilename) {
   let categoryArray;
   if (category.includes("/")) {
     const [primary, ...tags] = category.split("/");
-    categoryArray = (0, import_player_core.normalizeCategory)(primary, ...tags);
+    categoryArray = normalizeCategory(primary, ...tags);
   } else {
     categoryArray = [category];
   }

package/dist/babel/index.mjs

@@ -1,6 +1,6 @@
 import {
   babelPlugin
-} from "../chunk-OPJKP747.mjs";
+} from "../chunk-7JRAEFRB.mjs";
 import "../chunk-CIESM3BP.mjs";
 export {
   babelPlugin as default

package/dist/chunk-5FTDWKHH.mjs

@@ -0,0 +1,244 @@
+import {
+  createSourceEnvelope,
+  generateFsTree
+} from "./chunk-5M7DKKBC.mjs";
+import {
+  babelPlugin
+} from "./chunk-7JRAEFRB.mjs";
+
+// src/cli/build.ts
+import { glob } from "glob";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { transformSync } from "@babel/core";
+import { join, basename, dirname, resolve } from "path";
+import { execSync } from "child_process";
+async function build(options = {}) {
+  const srcDir = options.src ?? "src/workflows";
+  const outDir = options.outDir ?? "dist/workflows";
+  const mode = options.mode ?? "infer";
+  if (!options.skipTypeCheck) {
+    const tsconfigPath = resolve(srcDir, "tsconfig.json");
+    const hasTsconfig = existsSync(tsconfigPath);
+    if (hasTsconfig) {
+      console.log(`[mindmatrix-react] Type checking (tsc --noEmit)...`);
+      try {
+        execSync(`npx tsc --noEmit --project ${tsconfigPath}`, {
+          cwd: resolve(srcDir),
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+        console.log(`[mindmatrix-react] Type check passed.`);
+      } catch (err) {
+        const tscError = err;
+        const output = tscError.stdout || tscError.stderr || "";
+        const lines = output.split("\n").filter((l) => l.trim());
+        const typeErrors = [];
+        for (const line of lines) {
+          const match = line.match(/^(.+?)\((\d+),\d+\):\s*error\s+(TS\d+):\s*(.+)$/);
+          if (match) {
+            typeErrors.push({
+              file: match[1],
+              message: `${match[3]}: ${match[4]}`,
+              line: parseInt(match[2], 10)
+            });
+          }
+        }
+        if (typeErrors.length > 0) {
+          console.error(`
+[mindmatrix-react] Type check failed with ${typeErrors.length} error(s):
+`);
+          for (const te of typeErrors) {
+            console.error(`  \u2717 ${te.file}:${te.line || "?"} ${te.message}`);
+          }
+          console.error(`
+[mindmatrix-react] Fix type errors or use --skip-type-check to bypass.
+`);
+          return {
+            compiled: 0,
+            errors: typeErrors.length,
+            warnings: 0,
+            definitions: [],
+            errorDetails: typeErrors
+          };
+        } else {
+          console.error(`
+[mindmatrix-react] Type check failed:
+${output}`);
+          return {
+            compiled: 0,
+            errors: 1,
+            warnings: 0,
+            definitions: [],
+            errorDetails: [{ file: "tsconfig.json", message: output.slice(0, 500) }]
+          };
+        }
+      }
+    }
+  }
+  const configPath = resolve(srcDir, "mm.config.ts");
+  if (existsSync(configPath)) {
+    console.log(`[mindmatrix-react] Detected mm.config.ts \u2014 using project compiler...`);
+    const { compileProject } = await import("./project-compiler-NNK32MPG.mjs");
+    const allProjectFiles = await glob(`${srcDir}/**/*.{ts,tsx}`, {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
+    });
+    const fileMap = {};
+    for (const f of allProjectFiles) {
+      const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
+      fileMap[rel] = readFileSync(f, "utf-8");
+    }
+    mkdirSync(outDir, { recursive: true });
+    const result2 = compileProject(fileMap, { mode });
+    const errors = result2.errors.filter((e) => e.severity === "error");
+    const warnings = result2.errors.filter((e) => e.severity === "warning");
+    const definitions2 = [result2.ir];
+    const errorDetails2 = [];
+    for (const err of errors) {
+      errorDetails2.push({ file: err.file, message: err.message, line: err.line });
+      console.error(`  x ${err.file}${err.line ? `:${err.line}` : ""} ${err.message}`);
+    }
+    for (const warn of warnings) {
+      console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ""} ${warn.message}`);
+    }
+    const irPath = join(outDir, `${result2.ir.slug}.workflow.json`);
+    writeFileSync(irPath, JSON.stringify(result2.ir, null, 2), "utf-8");
+    console.log(`  + ${basename(irPath)}`);
+    const seenSlugs = /* @__PURE__ */ new Set([result2.ir.slug]);
+    for (const child of result2.childDefinitions) {
+      if (seenSlugs.has(child.slug)) continue;
+      seenSlugs.add(child.slug);
+      definitions2.push(child);
+      const childPath = join(outDir, `${child.slug}.workflow.json`);
+      writeFileSync(childPath, JSON.stringify(child, null, 2), "utf-8");
+      console.log(`  + ${basename(childPath)}`);
+    }
+    console.log(`
+[mindmatrix-react] Compiled ${definitions2.length} definitions, ${errors.length} errors, ${warnings.length} warnings`);
+    return { compiled: definitions2.length, errors: errors.length, warnings: warnings.length, definitions: definitions2, errorDetails: errorDetails2 };
+  }
+  console.log(`[mindmatrix-react] Building workflows from ${srcDir}...`);
+  mkdirSync(outDir, { recursive: true });
+  const workflowFiles = await glob(`${srcDir}/**/*.workflow.{tsx,ts,jsx,js}`);
+  const modelFiles = await glob(`${srcDir}/**/models/**/*.{ts,tsx}`);
+  const serverFiles = await glob(`${srcDir}/**/*.server.{ts,tsx,js,jsx}`);
+  const allFiles = [.../* @__PURE__ */ new Set([...workflowFiles, ...modelFiles, ...serverFiles])];
+  if (allFiles.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${srcDir}`);
+    return { compiled: 0, errors: 0, warnings: 0, definitions: [], errorDetails: [] };
+  }
+  let compiled = 0;
+  let errorCount = 0;
+  let warningCount = 0;
+  const definitions = [];
+  const errorDetails = [];
+  for (const file of allFiles) {
+    try {
+      const code = readFileSync(file, "utf-8");
+      const result2 = transformSync(code, {
+        filename: file,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: ["jsx", "typescript"], attachComment: true }
+      });
+      const ir = result2?.metadata?.mindmatrixIR;
+      const definition = result2?.metadata?.mindmatrixDefinition;
+      const canonical = result2?.metadata?.mindmatrixCanonical;
+      if (ir) {
+        definitions.push(ir);
+        const irErrors = ir.metadata?.errors;
+        const irWarnings = ir.metadata?.warnings;
+        if (irErrors && irErrors.length > 0) {
+          for (const err of irErrors) {
+            errorDetails.push({
+              file: basename(file),
+              message: err.message,
+              line: err.line
+            });
+            console.error(`  \u2717 ${basename(file)}:${err.line || "?"} ${err.message}`);
+          }
+          errorCount += irErrors.length;
+        }
+        if (irWarnings && irWarnings.length > 0) {
+          for (const warn of irWarnings) {
+            console.warn(`  \u26A0 ${basename(file)}:${warn.line || "?"} ${warn.message}`);
+          }
+          warningCount += irWarnings.length;
+        }
+        const compiledFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const compiledFile = join(outDir, compiledFileName);
+        mkdirSync(dirname(compiledFile), { recursive: true });
+        writeFileSync(compiledFile, JSON.stringify({ canonical, ir }, null, 2), "utf-8");
+        const irFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".workflow.json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const irFile = join(outDir, irFileName);
+        writeFileSync(irFile, JSON.stringify(ir, null, 2), "utf-8");
+        if (definition) {
+          const defFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".def.json").replace(/\.(tsx?|jsx?)$/, ".def.json");
+          const defFile = join(outDir, defFileName);
+          writeFileSync(defFile, JSON.stringify(definition, null, 2), "utf-8");
+        }
+        console.log(`  \u2713 ${basename(file)} \u2192 ${compiledFileName}`);
+        compiled++;
+      } else {
+        console.error(`  \u2717 ${basename(file)}: No IR generated`);
+        errorDetails.push({ file: basename(file), message: "No IR generated" });
+        errorCount++;
+      }
+    } catch (error) {
+      const msg = error.message;
+      console.error(`  \u2717 ${basename(file)}: ${msg}`);
+      errorDetails.push({ file: basename(file), message: msg });
+      errorCount++;
+    }
+  }
+  if (options.envelope) {
+    const allSourceFiles = await glob(`${srcDir}/**/*.{ts,tsx,js,jsx}`);
+    const fsTree = generateFsTree(allSourceFiles, resolve(srcDir));
+    const envelope = createSourceEnvelope({
+      blueprintSlug: options.slug || "project",
+      blueprintVersion: options.version || "0.1.0",
+      definitions,
+      fsTree,
+      mode
+    });
+    const envelopePath = join(outDir, "envelope.json");
+    writeFileSync(envelopePath, JSON.stringify(envelope, null, 2), "utf-8");
+    console.log(`
+  \u2713 Source envelope \u2192 envelope.json (${envelope.envelopeId.substring(0, 8)})`);
+  }
+  console.log(`
+[mindmatrix-react] Compiled ${compiled} workflows, ${errorCount} errors, ${warningCount} warnings`);
+  const result = { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+  if (options.watch) {
+    await startWatchMode(options);
+  }
+  return result;
+}
+async function startWatchMode(options) {
+  const { watch: fsWatch } = await import("fs");
+  const srcDir = options.src ?? "src/workflows";
+  let debounce = null;
+  console.log(`
+[mindmatrix-react] Watching ${srcDir} for changes... (Ctrl+C to stop)
+`);
+  fsWatch(srcDir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (!filename.match(/\.(tsx?|jsx?)$/)) return;
+    if (filename.includes("node_modules") || filename.includes("dist")) return;
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`
+[${ts}] Change detected: ${filename} \u2014 recompiling...`);
+      try {
+        await build({ ...options, watch: false, skipTypeCheck: true });
+      } catch (e) {
+        console.error(`[mindmatrix-react] Rebuild failed:`, e.message);
+      }
+    }, 300);
+  });
+  return new Promise(() => {
+  });
+}
+
+export {
+  build
+};