@flatkit/compiler 0.35.3 → 0.36.1

package/bin/flatc.mjs

@@ -20,4 +20,11 @@ try {
 
 const code = await run(process.argv) // `--render` is async (SVG decode + raster)
 // In --watch mode, `fs.watch` keeps the process alive: do not exit (otherwise we kill the watcher).
-if (!process.argv.includes('--watch')) process.exit(code)
+if (!process.argv.includes('--watch')) {
+  // Let both streams DRAIN first. A write to a pipe is asynchronous on macOS and Windows, and
+  // `process.exit` does not wait for it: a report longer than the pipe's buffer (64 KB) was cut off
+  // mid-line whenever the output was piped into another tool — and whole when sent to a file or a terminal.
+  const drained = (stream) => new Promise((done) => stream.write('', () => done()))
+  await Promise.all([drained(process.stdout), drained(process.stderr)])
+  process.exit(code)
+}

package/dist/analysis.js

@@ -27,7 +27,7 @@ import {
   scopeRegions,
   splitScopeProgram,
   wrapMetrics
-} from "./chunk-W3YUC6BC.js";
+} from "./chunk-43MGBTUK.js";
 import "./chunk-KXKX2RMX.js";
 export {
   allScopeVariables,

package/dist/{chunk-W3YUC6BC.js → chunk-43MGBTUK.js}

@@ -197,7 +197,7 @@ import { objectNames } from "@flatkit/engine/sceneRefs";
 import { behaviorRegions } from "@flatkit/engine/flatFormat";
 import { itemBBox, itemBoundsById, dropZoneBounds, transformBBox, revealGrid } from "@flatkit/engine/groups";
 import { IDENTITY, apply, compose } from "@flatkit/engine/transform";
-import { makePathSampler } from "@flatkit/engine/path";
+import { makePathSampler, softVertexCount, smoothingDeviation } from "@flatkit/engine/path";
 import { bboxIntersects } from "@flatkit/engine/bbox";
 
 // src/docWalk.ts
@@ -262,6 +262,11 @@ function forEachLeafExpression(it, fn) {
   if (isRegion(it)) {
     if (it.drawExpr) fn(it.drawExpr);
     if (it.drawFromExpr) fn(it.drawFromExpr);
+    if (it.poly) {
+      fn(it.poly.xs);
+      fn(it.poly.ys);
+      if (it.poly.count !== void 0) fn(it.poly.count);
+    }
   }
 }
 function forEachExpression(doc, fn) {
@@ -288,6 +293,7 @@ function forEachExpression(doc, fn) {
   }
   for (const i of doc.interactions ?? []) forEachActionExpression(i.actions, fn);
   for (const f of doc.functions ?? []) if (f.kind === "proc") forEachActionExpression(f.body, fn);
+  else fn(f.expr);
   for (const t of [doc.timeline, ...(doc.symbols ?? []).map((s) => s.timeline)]) {
     if (!t) continue;
     forEachActionExpression(t.onLoad, fn);
@@ -298,13 +304,14 @@ function forEachExpression(doc, fn) {
 
 // src/programDoc.ts
 import { parseUnits as parseUnits2 } from "@flatkit/engine/dsl";
+import { MATH_CTX, STD_CONSTANTS as STD_CONSTANTS2, STD_IDS as STD_IDS2 } from "@flatkit/engine/expr";
 function scopeProgram(doc, editPath = []) {
   const atRoot = editPath.length === 0;
   const items = contextLayers(doc, editPath).flatMap((l) => l.items);
   const nameCount = /* @__PURE__ */ new Map();
   for (const it of items) if (isContainer(it) && it.name) nameCount.set(it.name, (nameCount.get(it.name) ?? 0) + 1);
-  const scripted = (it) => !!doc.interactions?.some((i) => i.targetId === it.id) || !!doc.interactors?.some((i) => i.targetId === it.id) || !!(it.expressions && Object.keys(it.expressions).length);
-  const objects = items.filter((it) => isContainer(it) && !!it.name && nameCount.get(it.name) === 1 && scripted(it)).map((it) => ({ name: it.name, body: printUnits(objectToUnits(it.id, doc.interactions, it.expressions, doc.interactors)) }));
+  const scripted = (it) => !!doc.interactions?.some((i) => i.targetId === it.id) || !!doc.interactors?.some((i) => i.targetId === it.id) || !!(it.expressions && Object.keys(it.expressions).length) || !!it.focusable;
+  const objects = items.filter((it) => isContainer(it) && !!it.name && nameCount.get(it.name) === 1 && scripted(it)).map((it) => ({ name: it.name, body: printUnits(objectToUnits(it.id, doc.interactions, it.expressions, doc.interactors, void 0, it.focusable)) }));
   const imports = atRoot ? printUnits(importsToUnits(doc.imports)) : "";
   const funcs = atRoot ? printUnits(functionsToUnits((doc.functions ?? []).filter((f) => !f.name.includes(".")))) : "";
   const globals = atRoot ? printUnits(variablesToUnits(doc.variables)) : "";
@@ -408,6 +415,102 @@ function timeCapturedVars(doc) {
   });
   return out;
 }
+function didYouMean(word, names) {
+  const dist = (a, b) => {
+    const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+      let prev = row[0];
+      row[0] = i;
+      for (let j = 1; j <= b.length; j++) {
+        const t = row[j];
+        row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+        prev = t;
+      }
+    }
+    return row[b.length];
+  };
+  const best = names.map((n) => ({ n, d: dist(word, n) })).filter((x) => x.d <= 2).sort((a, b) => a.d - b.d)[0];
+  return best ? ` \u2014 did you mean "${best.n}"?` : "";
+}
+var COLOR_LITERAL = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function instanceParamWarnings(doc) {
+  const out = [];
+  const names = (sym) => [...(sym.params ?? []).map((p) => p.name), ...(sym.states ?? []).map((sm) => sm.param)];
+  const stateNames = (sym, param) => sym.states?.find((sm) => sm.param === param)?.states.map((st) => st.name);
+  const checkLiteral = (who, sym, key, value) => {
+    const def = sym.params?.find((p) => p.name === key);
+    const states = stateNames(sym, key);
+    if (!def && !states) {
+      out.push(`${who}: unknown param "${key}" (symbol "${sym.name}")${didYouMean(key, names(sym))}`);
+      return;
+    }
+    if (states) {
+      if (!states.includes(value) && !Number.isFinite(Number(value))) out.push(`${who}: "${value}" is not a state of "${key}" (${states.join(", ")})`);
+      return;
+    }
+    if (def.type === "color") {
+      if (!COLOR_LITERAL.test(value)) out.push(`${who}: "${key}" is a color param and was given "${value}"`);
+    } else if (def.type === "bool") {
+      if (!["true", "false", "0", "1"].includes(value)) out.push(`${who}: "${key}" is true or false, and was given "${value}"`);
+    } else if (def.type === "number") {
+      const v = Number(value);
+      if (!Number.isFinite(v)) out.push(`${who}: "${key}" is a number param and was given "${value}"`);
+      else if (def.min != null && def.max != null && def.min <= def.max && (v < def.min || v > def.max)) out.push(`${who}: "${key}" = ${value} is outside its range ${def.min}..${def.max} (it is clamped)`);
+    }
+  };
+  const byName = /* @__PURE__ */ new Map();
+  const visit = (items, atRoot) => {
+    for (const it of items) {
+      if (isGroup2(it)) {
+        for (const l of it.layers) visit(l.items, atRoot);
+        continue;
+      }
+      if (!isInstance(it)) continue;
+      const sym = doc.symbols.find((x) => x.id === it.symbolId);
+      if (!sym) continue;
+      if (atRoot && it.name && !byName.has(it.name)) byName.set(it.name, sym);
+      for (const [k, v] of Object.entries(it.params ?? {})) checkLiteral(`instance "${it.name}"`, sym, k, v);
+    }
+  };
+  for (const l of doc.layers) visit(l.items, true);
+  for (const sy of doc.symbols ?? []) for (const l of sy.layers) visit(l.items, false);
+  const known = /* @__PURE__ */ new Set([...Object.keys(doc.variables ?? {}), ...(doc.functions ?? []).flatMap((f) => f.params)]);
+  const reported = /* @__PURE__ */ new Set();
+  const say = (m) => {
+    if (!reported.has(m)) {
+      reported.add(m);
+      out.push(m);
+    }
+  };
+  forEachAction(doc, (a) => {
+    if (a.do !== "setParam") return;
+    const sym = byName.get(a.target);
+    if (!sym) {
+      say(`no instance named "${a.target}" in the scene \u2014 \`${a.target}.${a.param} = \u2026\` does nothing${didYouMean(a.target, [...byName.keys()])}`);
+      return;
+    }
+    const who = `${a.target}.${a.param} = \u2026`;
+    const value = a.value.trim();
+    const def = sym.params?.find((p) => p.name === a.param);
+    const states = stateNames(sym, a.param);
+    if (!def && !states) {
+      say(`${who}: unknown param "${a.param}" (symbol "${sym.name}")${didYouMean(a.param, names(sym))}`);
+      return;
+    }
+    if (states) {
+      if (/^[A-Za-z_]\w*$/.test(value) && !states.includes(value) && !known.has(value)) say(`${who}: "${value}" is not a state of "${a.param}" (${states.join(", ")})`);
+    } else if (def.type === "color") {
+      if (!COLOR_LITERAL.test(value)) say(`${who}: "${a.param}" is a color param \u2014 it takes a color literal (#rrggbb), not an expression`);
+    } else if (def.type === "text") {
+      if (!/^".*"$/.test(value)) say(`${who}: "${a.param}" is a text param \u2014 it takes a quoted text`);
+    } else if (/^-?[\d.]+$/.test(value)) {
+      const before = out.length;
+      checkLiteral(who, sym, a.param, value);
+      for (const m of out.splice(before)) say(m);
+    }
+  });
+  return out;
+}
 function docStructureWarnings(doc) {
   const out = [];
   const names = new Set(objectNames(doc.layers));
@@ -443,6 +546,70 @@ function docStructureWarnings(doc) {
         out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `global variable "${name}" never used (declared, but neither read nor written)` } });
     }
   }
+  const hiddenBy = (name) => STD_CONSTANTS2.includes(name) ? `the constant ${name}` : Object.hasOwn(MATH_CTX, name) ? `the function ${name}()` : STD_IDS2.includes(name) ? `the reserved name ${name}` : void 0;
+  const valueFns = new Set([...doc.functions ?? [], ...importedFunctions(doc.imports)].filter((f) => f.kind === "value").map((f) => f.name));
+  for (const name of names0) {
+    const by = hiddenBy(name) ?? (valueFns.has(name) ? `the function ${name}()` : void 0);
+    if (by) out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `variable "${name}" is hidden by ${by} \u2014 every read returns that, never the variable. Rename it` } });
+  }
+  for (const f of doc.functions ?? []) {
+    if (f.name.includes(".")) continue;
+    for (const p of f.params) {
+      const by = hiddenBy(p);
+      if (by) out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `parameter "${p}" of fn ${f.name} is hidden by ${by} \u2014 the body reads that, never the argument. Rename it` } });
+    }
+  }
+  const looksLikeMaterial = (r) => {
+    for (const sp of r.path.subpaths) {
+      const n = sp.segments.length;
+      if (n < 12) continue;
+      const handles = sp.segments.flatMap((sg) => [[sg.inHandle, sg.anchor], [sg.outHandle, sg.anchor]]).filter(([h]) => h !== void 0);
+      if (!handles.length || handles.some(([h, a]) => h.x !== a.x || h.y !== a.y)) continue;
+      const xs = sp.segments.map((sg) => sg.anchor.x), ys = sp.segments.map((sg) => sg.anchor.y);
+      const size = Math.hypot(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys));
+      if (softVertexCount(sp) >= n * 0.75 && smoothingDeviation(sp) >= Math.max(1, size * 4e-3)) return n;
+    }
+    return 0;
+  };
+  const scanMaterial = (items) => {
+    for (const it of items) {
+      if (isRegion2(it) && !it.poly) {
+        const n = looksLikeMaterial(it);
+        if (n) out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: `a path of ${n} points with no curve is drawn with straight segments \u2014 if it is free-hand material or a sampled curve, write \`smooth\` after its path data (\`path "\u2026" smooth\`) to have it rounded` } });
+      }
+      if (isGroup2(it)) for (const l of it.layers) {
+        scanMaterial(l.items);
+        for (const c of l.cels ?? []) scanMaterial(c.matter ?? []);
+      }
+    }
+  };
+  for (const l of [...doc.layers, ...(doc.symbols ?? []).flatMap((sy) => sy.layers)]) {
+    scanMaterial(l.items);
+    for (const c of l.cels ?? []) scanMaterial(c.matter ?? []);
+  }
+  const polyNames = /* @__PURE__ */ new Set();
+  const scanPoly = (items) => {
+    for (const it of items) {
+      if (isRegion2(it) && it.poly) {
+        polyNames.add(it.poly.xs);
+        polyNames.add(it.poly.ys);
+      }
+      if (isGroup2(it)) for (const l of it.layers) {
+        scanPoly(l.items);
+        for (const c of l.cels ?? []) scanPoly(c.matter ?? []);
+      }
+    }
+  };
+  for (const l of [...doc.layers, ...(doc.symbols ?? []).flatMap((sy) => sy.layers)]) {
+    scanPoly(l.items);
+    for (const c of l.cels ?? []) scanPoly(c.matter ?? []);
+  }
+  for (const name of polyNames) {
+    const v = doc.variables?.[name];
+    if (Array.isArray(v)) continue;
+    out.push({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message: v === void 0 ? `polyline: "${name}" is not declared \u2014 it takes two array variables (\`var ${name} = fill(<n>, 0)\`); nothing is drawn` : `polyline: "${name}" is a number, not an array (\`var ${name} = fill(<n>, 0)\`); nothing is drawn` } });
+  }
+  out.push(...instanceParamWarnings(doc).map((message) => ({ scope: "scene", diag: { line: 1, col: 1, severity: "warning", message } })));
   const missing = /* @__PURE__ */ new Set();
   const scanRefs = (items) => {
     for (const it of items) {
@@ -808,7 +975,7 @@ function docLayoutWarnings(doc) {
   const zones = [];
   const collectZones = (layers) => {
     for (const l of layers) for (const it of l.items) {
-      if (isGroup2(it) && it.hitbox && it.name) {
+      if ((isGroup2(it) || isInstance(it)) && it.hitbox && it.name) {
         const b = dropZoneBounds(doc, it.name);
         if (b) zones.push({ name: it.name, b });
       }
@@ -816,6 +983,8 @@ function docLayoutWarnings(doc) {
     }
   };
   collectZones(doc.layers);
+  const dropTargets = new Set((doc.interactions ?? []).filter((it) => it.event === "drop" && it.over).map((it) => it.over));
+  for (let k = zones.length - 1; k >= 0; k--) if (!dropTargets.has(zones[k].name)) zones.splice(k, 1);
   for (let i = 0; i < zones.length; i++) for (let j = i + 1; j < zones.length; j++) {
     if (bboxIntersects(zones[i].b, zones[j].b)) out.push(warn(`overlapping hitboxes: "${zones[i].name}" and "${zones[j].name}" -> ambiguous drop`));
   }
@@ -1012,4 +1181,4 @@ export {
   applyFixes,
   repairLoop
 };
-//# sourceMappingURL=chunk-W3YUC6BC.js.map
+//# sourceMappingURL=chunk-43MGBTUK.js.map