fluidcad 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluidcad",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Parametric CAD modeling library using javascript",
   "author": "Marwan Aouida <contact@marwan.dev>",
   "homepage": "https://fluidcad.io",
@@ -39,7 +39,7 @@
     "./server": "./server/dist/index.js"
   },
   "scripts": {
-    "clean": "rm -rf lib/dist server/dist ui/dist",
+    "clean": "rm -rf lib/dist server/dist ui/dist lib/tsconfig.tsbuildinfo server/tsconfig.tsbuildinfo",
     "build:lib": "tsc -p lib/tsconfig.json",
     "build:server": "tsc -p server/tsconfig.json",
     "build:ui": "vite build --config ui/vite.config.ts",

package/server/dist/fluidcad-server.d.ts

@@ -0,0 +1,32 @@
+export type SceneRenderedData = {
+    absPath: string;
+    result: any[];
+    rollbackStop: number;
+};
+export declare class FluidCadServer {
+    private viteManager;
+    private sceneManager;
+    private previousScenes;
+    private renderingCache;
+    private currentFileName;
+    init(workspacePath: string): Promise<void>;
+    processFile(filePath: string, ignoreCache?: boolean): Promise<SceneRenderedData | null>;
+    updateLiveCode(fileName: string, code: string): Promise<SceneRenderedData | null>;
+    rollbackFromUI(index: number): Promise<SceneRenderedData | null>;
+    rollback(fileName: string, index: number): Promise<SceneRenderedData | null>;
+    importFile(workspacePath: string, fileName: string, data: string): Promise<void>;
+    getShapeProperties(shapeId: string): any;
+    getFaceProperties(shapeId: string, faceIndex: number): any;
+    getEdgeProperties(shapeId: string, edgeIndex: number): any;
+    exportShapes(shapeIds: string[], options: {
+        format: 'step' | 'stl';
+        includeColors?: boolean;
+        resolution?: string;
+        customLinearDeflection?: number;
+        customAngularDeflectionDeg?: number;
+    }): {
+        data: string | Uint8Array;
+        fileName: string;
+    } | null;
+    hitTest(shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): any;
+}

package/server/dist/fluidcad-server.js

@@ -0,0 +1,150 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { ViteManager } from "./vite-manager.js";
+export class FluidCadServer {
+    viteManager = new ViteManager();
+    sceneManager;
+    previousScenes = new Map();
+    renderingCache = new Map();
+    currentFileName = '';
+    async init(workspacePath) {
+        await this.viteManager.init(workspacePath);
+        const initFilePath = join(workspacePath, 'init.js');
+        if (existsSync(initFilePath)) {
+            const { default: _sceneManager } = await this.viteManager.loadModule(initFilePath);
+            this.sceneManager = await _sceneManager;
+        }
+    }
+    async processFile(filePath, ignoreCache = false) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const normalizedFileName = filePath.replace('virtual:live-render:', '');
+        this.currentFileName = normalizedFileName;
+        if (!ignoreCache) {
+            const fromCache = this.renderingCache.get(normalizedFileName);
+            if (fromCache) {
+                return {
+                    absPath: normalizedFileName,
+                    result: fromCache,
+                    rollbackStop: fromCache.length - 1,
+                };
+            }
+        }
+        try {
+            let scene = this.sceneManager.startScene();
+            this.sceneManager.setCurrentFile(normalizedFileName);
+            this.viteManager.invalidateModule();
+            await this.viteManager.loadModule(filePath);
+            if (this.previousScenes.has(normalizedFileName)) {
+                const previousScene = this.previousScenes.get(normalizedFileName);
+                scene = this.sceneManager.compare(previousScene, scene);
+            }
+            this.previousScenes.set(normalizedFileName, scene);
+            this.sceneManager.renderScene(scene);
+            const result = scene.getRenderedObjects();
+            for (const obj of result) {
+                if (obj.sourceLocation) {
+                    obj.sourceLocation.filePath = obj.sourceLocation.filePath.replace('virtual:live-render:', '');
+                }
+            }
+            if (!filePath.startsWith('virtual:live-render')) {
+                this.renderingCache.set(normalizedFileName, result);
+            }
+            return {
+                absPath: normalizedFileName,
+                result,
+                rollbackStop: result.length - 1,
+            };
+        }
+        catch (error) {
+            this.viteManager.invalidateModule();
+            console.log('Error processing file:', error);
+            throw error;
+        }
+    }
+    async updateLiveCode(fileName, code) {
+        const id = `virtual:live-render:${fileName}`;
+        this.viteManager.setBuffer(id, code);
+        this.renderingCache.delete(fileName);
+        return this.processFile(id, true);
+    }
+    async rollbackFromUI(index) {
+        return this.rollback(this.currentFileName, index);
+    }
+    async rollback(fileName, index) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(fileName);
+        if (!scene) {
+            return null;
+        }
+        const totalObjects = scene.getAllSceneObjects().length;
+        const rollbackIndex = index >= totalObjects - 1 ? totalObjects - 1 : index;
+        this.sceneManager.rollbackScene(scene, rollbackIndex);
+        const result = scene.getRenderedObjects();
+        return {
+            absPath: fileName,
+            result,
+            rollbackStop: index,
+        };
+    }
+    async importFile(workspacePath, fileName, data) {
+        if (!this.sceneManager) {
+            throw new Error('SceneManager not initialized');
+        }
+        const binaryData = Buffer.from(data, 'base64');
+        await this.sceneManager.importFile(workspacePath, fileName, binaryData);
+    }
+    getShapeProperties(shapeId) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getShapeProperties(scene, shapeId);
+    }
+    getFaceProperties(shapeId, faceIndex) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getFaceProperties(scene, shapeId, faceIndex);
+    }
+    getEdgeProperties(shapeId, edgeIndex) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getEdgeProperties(scene, shapeId, edgeIndex);
+    }
+    exportShapes(shapeIds, options) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.exportShapes(scene, shapeIds, options);
+    }
+    hitTest(shapeId, rayOrigin, rayDir, edgeThreshold) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
+    }
+}

package/server/dist/index.d.ts

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

package/server/dist/index.js

@@ -0,0 +1,290 @@
+import crypto from 'crypto';
+import http from 'http';
+import path from 'path';
+import express from 'express';
+import { WebSocketServer, WebSocket } from 'ws';
+import { FluidCadServer } from "./fluidcad-server.js";
+import { createPropertiesRouter } from "./routes/properties.js";
+import { createActionsRouter } from "./routes/actions.js";
+import { createExportRouter } from "./routes/export.js";
+import { createScreenshotRouter } from "./routes/screenshot.js";
+const PORT = parseInt(process.env.FLUIDCAD_SERVER_PORT || '3100', 10);
+const WORKSPACE_PATH = process.env.FLUIDCAD_WORKSPACE_PATH || '';
+const UI_DIST = path.resolve(import.meta.dirname, '../../ui/dist');
+// ---------------------------------------------------------------------------
+// IPC helpers — communication with extension host process
+// ---------------------------------------------------------------------------
+function sendToExtension(msg) {
+    if (process.send) {
+        process.send(msg);
+    }
+}
+// ---------------------------------------------------------------------------
+// Express app
+// ---------------------------------------------------------------------------
+const fluidCadServer = new FluidCadServer();
+const app = express();
+app.use(express.json({ limit: '50mb' }));
+app.use('/api', createPropertiesRouter(fluidCadServer));
+app.use('/api', createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, WORKSPACE_PATH));
+app.use('/api', createExportRouter(fluidCadServer));
+app.use('/api', createScreenshotRouter(requestScreenshot));
+// Static files — serve UI build, with SPA fallback
+app.use(express.static(UI_DIST, {
+    setHeaders(res, filePath) {
+        if (path.extname(filePath) === '.html') {
+            res.setHeader('Cache-Control', 'no-cache');
+        }
+    },
+}));
+app.get('*splat', (_req, res) => {
+    res.setHeader('Cache-Control', 'no-cache');
+    res.sendFile(path.join(UI_DIST, 'index.html'));
+});
+// ---------------------------------------------------------------------------
+// HTTP + WebSocket server
+// ---------------------------------------------------------------------------
+const httpServer = http.createServer(app);
+const wss = new WebSocketServer({ server: httpServer });
+const uiClients = new Set();
+let lastSceneMessage = null;
+let initCompleteMessage = null;
+function broadcastToUI(msg) {
+    const data = JSON.stringify(msg);
+    if (msg.type === 'scene-rendered') {
+        lastSceneMessage = data;
+    }
+    if (msg.type === 'init-complete') {
+        initCompleteMessage = data;
+    }
+    for (const client of uiClients) {
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(data);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Screenshot request/response coordination
+// ---------------------------------------------------------------------------
+const SCREENSHOT_TIMEOUT_MS = 10_000;
+const pendingScreenshots = new Map();
+function requestScreenshot(options) {
+    return new Promise((resolve, reject) => {
+        if (uiClients.size === 0) {
+            reject(new Error('No UI client connected.'));
+            return;
+        }
+        const requestId = crypto.randomUUID();
+        const timeout = setTimeout(() => {
+            pendingScreenshots.delete(requestId);
+            reject(new Error('Screenshot request timed out.'));
+        }, SCREENSHOT_TIMEOUT_MS);
+        pendingScreenshots.set(requestId, {
+            resolve(data) {
+                clearTimeout(timeout);
+                pendingScreenshots.delete(requestId);
+                resolve(data);
+            },
+            reject(err) {
+                clearTimeout(timeout);
+                pendingScreenshots.delete(requestId);
+                reject(err);
+            },
+        });
+        broadcastToUI({ type: 'take-screenshot', requestId, options });
+    });
+}
+function handleUIMessage(raw) {
+    let msg;
+    try {
+        msg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    if (msg.type === 'screenshot-result' && msg.requestId) {
+        const pending = pendingScreenshots.get(msg.requestId);
+        if (!pending) {
+            return;
+        }
+        if (msg.success && msg.data) {
+            pending.resolve(Buffer.from(msg.data, 'base64'));
+        }
+        else {
+            pending.reject(new Error(msg.error || 'Screenshot failed.'));
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// WebSocket connections
+// ---------------------------------------------------------------------------
+wss.on('connection', (ws) => {
+    uiClients.add(ws);
+    // Replay init-complete and last scene to newly connected UI client
+    if (initCompleteMessage) {
+        ws.send(initCompleteMessage);
+    }
+    if (lastSceneMessage) {
+        ws.send(lastSceneMessage);
+    }
+    ws.on('message', (data) => {
+        handleUIMessage(String(data));
+    });
+    ws.on('close', () => {
+        uiClients.delete(ws);
+    });
+});
+// ---------------------------------------------------------------------------
+// IPC message handling — extension host → server
+// ---------------------------------------------------------------------------
+let currentFile = null;
+let renderVersion = 0;
+async function handleExtensionMessage(msg) {
+    try {
+        switch (msg.type) {
+            case 'process-file': {
+                const myVersion = ++renderVersion;
+                broadcastToUI({ type: 'processing-file' });
+                currentFile = msg.filePath;
+                const data = await fluidCadServer.processFile(msg.filePath);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                    });
+                }
+                break;
+            }
+            case 'live-update': {
+                const myVersion = ++renderVersion;
+                if (msg.fileName !== currentFile) {
+                    broadcastToUI({ type: 'processing-file' });
+                    currentFile = msg.fileName;
+                }
+                const data = await fluidCadServer.updateLiveCode(msg.fileName, msg.code);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                    });
+                }
+                break;
+            }
+            case 'rollback': {
+                const myVersion = ++renderVersion;
+                const data = await fluidCadServer.rollback(msg.fileName, msg.index);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                        rollbackStop: data.rollbackStop,
+                    });
+                }
+                break;
+            }
+            case 'import-file': {
+                try {
+                    await fluidCadServer.importFile(msg.workspacePath, msg.fileName, msg.data);
+                    sendToExtension({ type: 'import-complete', success: true });
+                }
+                catch (err) {
+                    sendToExtension({ type: 'error', message: err.stack || err.message || String(err) });
+                }
+                break;
+            }
+            case 'highlight-shape': {
+                broadcastToUI({ type: 'highlight-shape', shapeId: msg.shapeId });
+                break;
+            }
+            case 'clear-highlight': {
+                broadcastToUI({ type: 'clear-highlight' });
+                break;
+            }
+            case 'show-shape-properties': {
+                broadcastToUI({ type: 'show-shape-properties', shapeId: msg.shapeId });
+                break;
+            }
+            case 'export-scene': {
+                try {
+                    const result = fluidCadServer.exportShapes(msg.shapeIds, msg.options);
+                    if (result) {
+                        const data = typeof result.data === 'string'
+                            ? Buffer.from(result.data, 'utf-8').toString('base64')
+                            : Buffer.from(result.data).toString('base64');
+                        sendToExtension({
+                            type: 'export-complete',
+                            success: true,
+                            data,
+                            fileName: result.fileName,
+                        });
+                    }
+                    else {
+                        sendToExtension({ type: 'export-complete', success: false, error: 'No active scene to export.' });
+                    }
+                }
+                catch (err) {
+                    sendToExtension({ type: 'export-complete', success: false, error: err.message || String(err) });
+                }
+                break;
+            }
+        }
+    }
+    catch (err) {
+        sendToExtension({
+            type: 'error',
+            message: err.stack || err.message || String(err),
+        });
+    }
+}
+// Listen for IPC messages from extension host
+process.on('message', (msg) => {
+    handleExtensionMessage(msg);
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+httpServer.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`FluidCAD server listening on ${url}`);
+    // Signal ready immediately so extension can show the webview
+    sendToExtension({ type: 'ready', port: PORT, url });
+    // Initialize FluidCAD server in the background
+    fluidCadServer.init(WORKSPACE_PATH).then(() => {
+        sendToExtension({ type: 'init-complete', success: true });
+        broadcastToUI({ type: 'init-complete', success: true });
+    }).catch((err) => {
+        const error = err.stack || err.message || String(err);
+        sendToExtension({ type: 'init-complete', success: false, error });
+        broadcastToUI({ type: 'init-complete', success: false, error });
+    });
+});

package/server/dist/routes/actions.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createActionsRouter(fluidCadServer: FluidCadServer, sendToExtension: (msg: any) => void, broadcastToUI: (msg: any) => void, workspacePath: string): Router;

package/server/dist/routes/actions.js

@@ -0,0 +1,100 @@
+import { Router } from 'express';
+export function createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, workspacePath) {
+    const router = Router();
+    router.post('/hit-test', (req, res) => {
+        const { shapeId, rayOrigin, rayDir, edgeThreshold } = req.body;
+        if (typeof shapeId !== 'string' ||
+            !Array.isArray(rayOrigin) || rayOrigin.length !== 3 ||
+            !Array.isArray(rayDir) || rayDir.length !== 3 ||
+            typeof edgeThreshold !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        const result = fluidCadServer.hitTest(shapeId, rayOrigin, rayDir, edgeThreshold);
+        res.json(result);
+    });
+    router.post('/insert-point', (req, res) => {
+        const { point, sourceLocation } = req.body;
+        if (!Array.isArray(point) || point.length !== 2 ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'insert-point',
+            point: point,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/remove-point', (req, res) => {
+        const { point, sourceLocation } = req.body;
+        if (!Array.isArray(point) || point.length !== 2 ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'remove-point',
+            point: point,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/rollback', async (req, res) => {
+        const { index } = req.body;
+        if (typeof index !== 'number' || index < 0) {
+            res.status(400).json({ error: 'Invalid index' });
+            return;
+        }
+        const data = await fluidCadServer.rollbackFromUI(index);
+        if (!data) {
+            res.status(404).json({ error: 'No active scene' });
+            return;
+        }
+        sendToExtension({
+            type: 'scene-rendered',
+            absPath: data.absPath,
+            result: data.result,
+            rollbackStop: data.rollbackStop,
+        });
+        broadcastToUI({
+            type: 'scene-rendered',
+            result: data.result,
+            absPath: data.absPath,
+            rollbackStop: data.rollbackStop,
+        });
+        res.json({ success: true });
+    });
+    router.post('/set-pick-points', (req, res) => {
+        const { points, sourceLocation } = req.body;
+        if (!Array.isArray(points) ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'set-pick-points',
+            points: points,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/import-file', async (req, res) => {
+        const { fileName, data } = req.body;
+        if (typeof fileName !== 'string' || typeof data !== 'string') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        try {
+            await fluidCadServer.importFile(workspacePath, fileName, data);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || String(err) });
+            return;
+        }
+        const loadName = fileName.replace(/\.(step|stp)$/i, '');
+        res.json({ success: true, fileName: loadName });
+    });
+    return router;
+}

package/server/dist/routes/export.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createExportRouter(fluidCadServer: FluidCadServer): Router;

package/server/dist/routes/export.js

@@ -0,0 +1,55 @@
+import { Router } from 'express';
+export function createExportRouter(fluidCadServer) {
+    const router = Router();
+    router.post('/export', (req, res) => {
+        const { format, shapeIds, includeColors, resolution, customAngularDeflectionDeg, customLinearDeflection } = req.body;
+        if (format !== 'step' && format !== 'stl') {
+            res.status(400).json({ error: 'Invalid format. Must be "step" or "stl".' });
+            return;
+        }
+        if (!Array.isArray(shapeIds) || shapeIds.length === 0) {
+            res.status(400).json({ error: 'shapeIds must be a non-empty array.' });
+            return;
+        }
+        if (format === 'stl') {
+            const validResolutions = ['coarse', 'medium', 'fine', 'custom'];
+            if (resolution && !validResolutions.includes(resolution)) {
+                res.status(400).json({ error: 'Invalid resolution.' });
+                return;
+            }
+            if (resolution === 'custom') {
+                if (typeof customLinearDeflection !== 'number' || typeof customAngularDeflectionDeg !== 'number') {
+                    res.status(400).json({ error: 'Custom resolution requires customLinearDeflection and customAngularDeflectionDeg.' });
+                    return;
+                }
+            }
+        }
+        try {
+            const result = fluidCadServer.exportShapes(shapeIds, {
+                format,
+                includeColors,
+                resolution: resolution || 'medium',
+                customLinearDeflection,
+                customAngularDeflectionDeg,
+            });
+            if (!result) {
+                res.status(404).json({ error: 'No active scene to export.' });
+                return;
+            }
+            const ext = format === 'step' ? '.step' : '.stl';
+            const mimeType = format === 'step' ? 'application/step' : 'application/sla';
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Disposition', `attachment; filename="export${ext}"`);
+            if (typeof result.data === 'string') {
+                res.send(Buffer.from(result.data, 'utf-8'));
+            }
+            else {
+                res.send(Buffer.from(result.data));
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || String(err) });
+        }
+    });
+    return router;
+}

package/server/dist/routes/properties.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createPropertiesRouter(fluidCadServer: FluidCadServer): Router;