fluidcad 0.0.32 → 0.0.34

package/lib/dist/tests/helpers/extract-blocks.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+const FENCE_RE = /^(\s*)```([A-Za-z0-9_.-]*)\s*$/;
+const RUNNABLE_LANGS = new Set(["fluid.js", "fluid", "fluidjs"]);
+function listMarkdown(dir) {
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) {
+            continue;
+        }
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...listMarkdown(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+function extractFromFile(file, docsRoot) {
+    const text = fs.readFileSync(file, "utf8");
+    const lines = text.split("\n");
+    const rel = path.relative(docsRoot, file).split(path.sep).join("/");
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const openMatch = lines[i].match(FENCE_RE);
+        if (!openMatch || !RUNNABLE_LANGS.has(openMatch[2])) {
+            i++;
+            continue;
+        }
+        const startLine = i + 2;
+        const body = [];
+        i++;
+        while (i < lines.length) {
+            const closeMatch = lines[i].match(FENCE_RE);
+            if (closeMatch && closeMatch[2] === "") {
+                break;
+            }
+            body.push(lines[i]);
+            i++;
+        }
+        blocks.push({ file: rel, line: startLine, block: body.join("\n") });
+        i++;
+    }
+    return blocks;
+}
+export function extractFluidJsBlocks(docsRootRel) {
+    const docsRoot = path.resolve(docsRootRel);
+    const blocks = [];
+    for (const file of listMarkdown(docsRoot).sort()) {
+        blocks.push(...extractFromFile(file, docsRoot));
+    }
+    return blocks;
+}

package/lib/dist/tests/llm-docs-examples.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/llm-docs-examples.test.js

@@ -0,0 +1,62 @@
+// Runs every fluid.js fenced block in llm-docs/**/*.md against the real
+// FluidCAD runtime and asserts the scene compiles and produces ≥1 rendered
+// object. Catches three classes of doc rot:
+//
+//   1. Syntax errors in examples (renamed args, dropped commas, etc.).
+//   2. API drift — an example calls a method that no longer exists.
+//   3. Geometry-empty examples — the snippet runs but yields nothing visible,
+//      which usually means the user-facing intent broke.
+//
+// The runner reuses the global OCC init from global-setup.ts and the
+// startScene/render plumbing from setup.ts, so it sits on the same OCC
+// initialisation the rest of the test suite uses.
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "./setup.js";
+import { extractFluidJsBlocks } from "./helpers/extract-blocks.js";
+import * as core from "../core/index.js";
+import * as filters from "../filters/index.js";
+import * as constraints from "../features/2d/constraints/geometry-qualifier.js";
+import * as math from "../math/index.js";
+import { countShapes } from "./utils.js";
+function buildGlobals() {
+    return {
+        ...core,
+        ...filters,
+        ...constraints,
+        ...math,
+    };
+}
+// Doc examples often show the `import { foo } from "fluidcad/..."` line a
+// real user would write at the top of a .fluid.js file. The runner injects
+// every public export as a Function() parameter, so those imports are dead
+// weight here — and `new Function` can't parse them anyway. Strip them out
+// before executing.
+const IMPORT_LINE_RE = /^\s*import\s[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm;
+function stripImports(block) {
+    return block.replace(IMPORT_LINE_RE, "");
+}
+function runBlock(block, file, line) {
+    const globals = buildGlobals();
+    const paramNames = Object.keys(globals);
+    const paramValues = paramNames.map((n) => globals[n]);
+    const wrapped = `"use strict";\n${stripImports(block)}\n//# sourceURL=llm-docs/${file}:${line}`;
+    const fn = new Function(...paramNames, wrapped);
+    fn(...paramValues);
+}
+const blocks = extractFluidJsBlocks("llm-docs");
+describe("llm-docs fluid.js examples", () => {
+    setupOC();
+    if (blocks.length === 0) {
+        it("found at least one fluid.js block", () => {
+            expect(blocks.length).toBeGreaterThan(0);
+        });
+        return;
+    }
+    for (const { file, line, block } of blocks) {
+        it(`${file}:${line} compiles and produces ≥1 rendered object`, () => {
+            runBlock(block, file, line);
+            const scene = render();
+            expect(countShapes(scene)).toBeGreaterThan(0);
+        });
+    }
+});

package/lib/dist/tests/scene-compare.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/scene-compare.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "./setup.js";
+import { getSceneManager } from "../scene-manager.js";
+import { SceneCompare } from "../rendering/scene-compare.js";
+import sketch from "../core/sketch.js";
+import extrude from "../core/extrude.js";
+import { rect } from "../core/2d/index.js";
+function findByType(objects, uniqueType) {
+    const found = objects.find(o => o.getUniqueType() === uniqueType);
+    if (!found) {
+        throw new Error(`No object with uniqueType ${uniqueType}`);
+    }
+    return found;
+}
+describe("SceneCompare id preservation", () => {
+    setupOC();
+    it("inherits ids on matched objects across re-renders", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        render();
+        const previousScene = getSceneManager().currentScene;
+        const previousIds = previousScene.getSceneObjects().map(o => o.id);
+        const newScene = getSceneManager().startScene();
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        SceneCompare.compare(previousScene, newScene);
+        const newIds = newScene.getSceneObjects().map(o => o.id);
+        expect(newIds).toEqual(previousIds);
+    });
+    it("inherits ids only up to the divergence point", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        render();
+        const previousScene = getSceneManager().currentScene;
+        const previousSketchId = findByType(previousScene.getSceneObjects(), "sketch").id;
+        const previousExtrudeId = findByType(previousScene.getSceneObjects(), "extrude-by-distance").id;
+        const newScene = getSceneManager().startScene();
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(50);
+        const staleExtrudeId = findByType(newScene.getSceneObjects(), "extrude-by-distance").id;
+        SceneCompare.compare(previousScene, newScene);
+        const newSketchId = findByType(newScene.getSceneObjects(), "sketch").id;
+        const newExtrudeId = findByType(newScene.getSceneObjects(), "extrude-by-distance").id;
+        expect(newSketchId).toBe(previousSketchId);
+        expect(newExtrudeId).toBe(staleExtrudeId);
+        expect(newExtrudeId).not.toBe(previousExtrudeId);
+    });
+    it("keeps idMap consistent after id inheritance", () => {
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        render();
+        const previousScene = getSceneManager().currentScene;
+        const previousSketchId = findByType(previousScene.getSceneObjects(), "sketch").id;
+        const newScene = getSceneManager().startScene();
+        sketch("xy", () => {
+            rect(100, 50);
+        });
+        extrude(30);
+        const newSketch = findByType(newScene.getSceneObjects(), "sketch");
+        const staleSketchId = newSketch.id;
+        SceneCompare.compare(previousScene, newScene);
+        expect(newScene.getSceneObjectById(previousSketchId)).toBe(newSketch);
+        if (staleSketchId !== previousSketchId) {
+            expect(newScene.getSceneObjectById(staleSketchId)).toBe(null);
+        }
+    });
+});

package/lib/dist/tests/setup.js

@@ -1,7 +1,8 @@
 import { beforeEach } from "vitest";
 import { getSceneManager, getCurrentScene } from "../scene-manager.js";
 import { SceneRenderer } from "../rendering/render.js";
-const renderer = new SceneRenderer();
+import { DEFAULT_MESH_CONFIG } from "../oc/mesh.js";
+const renderer = new SceneRenderer(DEFAULT_MESH_CONFIG);
 export function setupOC() {
     beforeEach(() => {
         getSceneManager().startScene();