fluidcad 0.0.20 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluidcad",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Parametric CAD modeling library using javascript",
   "author": "Marwan Aouida <contact@marwan.dev>",
   "homepage": "https://fluidcad.io",

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

@@ -10,10 +10,12 @@ export declare class FluidCadServer {
     private previousScenes;
     private renderingCache;
     private currentFileName;
+    private currentFilePath;
     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>;
+    recomputeCurrentFile(): Promise<SceneRenderedData | null>;
     rollback(fileName: string, index: number): Promise<SceneRenderedData | null>;
     importFile(workspacePath: string, fileName: string, data: string): Promise<void>;
     getShapeProperties(shapeId: string): any;

package/server/dist/fluidcad-server.js

@@ -9,6 +9,7 @@ export class FluidCadServer {
     previousScenes = new Map();
     renderingCache = new Map();
     currentFileName = '';
+    currentFilePath = '';
     async init(workspacePath) {
         await this.viteManager.init(workspacePath);
         const initFilePath = normalizePath(join(workspacePath, 'init.js'));
@@ -24,6 +25,7 @@ export class FluidCadServer {
         filePath = normalizePath(filePath);
         const normalizedFileName = filePath.replace('virtual:live-render:', '');
         this.currentFileName = normalizedFileName;
+        this.currentFilePath = filePath;
         if (!ignoreCache) {
             const fromCache = this.renderingCache.get(normalizedFileName);
             if (fromCache) {
@@ -88,6 +90,14 @@ export class FluidCadServer {
     async rollbackFromUI(index) {
         return this.rollback(this.currentFileName, index);
     }
+    async recomputeCurrentFile() {
+        if (!this.currentFilePath) {
+            return null;
+        }
+        this.previousScenes.delete(this.currentFileName);
+        this.renderingCache.delete(this.currentFileName);
+        return this.processFile(this.currentFilePath, true);
+    }
     async rollback(fileName, index) {
         if (!this.sceneManager) {
             return null;

package/server/dist/routes/actions.js

@@ -67,6 +67,26 @@ export function createActionsRouter(fluidCadServer, sendToExtension, broadcastTo
         });
         res.json({ success: true });
     });
+    router.post('/recompute', async (_req, res) => {
+        const data = await fluidCadServer.recomputeCurrentFile();
+        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,
+            breakpointHit: data.breakpointHit,
+        });
+        res.json({ success: true });
+    });
     router.post('/clear-breakpoints', (_req, res) => {
         sendToExtension({ type: 'clear-breakpoints' });
         res.json({ success: true });

package/server/dist/vite-manager.js

@@ -103,7 +103,13 @@ export class ViteManager {
         this.buffers.set(id, code);
     }
     async loadModule(filePath) {
-        return this.server.ssrLoadModule(filePath);
+        const mod = await this.server.ssrLoadModule(filePath);
+        for (const value of Object.values(mod)) {
+            if (typeof value === 'function') {
+                await value();
+            }
+        }
+        return mod;
     }
     invalidateModule() {
         for (const [id, mod] of this.server.moduleGraph.idToModuleMap) {