fluidcad 0.0.2

package/bin/fluidcad.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { fork } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from 'util';
+import { writeFileSync, existsSync } from 'fs';
+import { createFileWatcher } from './watcher.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const { values, positionals } = parseArgs({
+  options: {
+    port: { type: 'string', short: 'p', default: '3100' },
+    workspace: { type: 'string', short: 'w', default: process.cwd() },
+  },
+  allowPositionals: true,
+});
+
+if (positionals[0] === 'init') {
+  const cwd = process.cwd();
+
+  const initPath = resolve(cwd, 'init.js');
+  if (existsSync(initPath)) {
+    console.error('init.js already exists in this directory.');
+    process.exit(1);
+  }
+
+  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default init()\n`);
+
+  const jsconfigPath = resolve(cwd, 'jsconfig.json');
+  if (!existsSync(jsconfigPath)) {
+    writeFileSync(jsconfigPath, JSON.stringify({
+      compilerOptions: {
+        checkJs: true,
+        module: 'node20',
+      },
+    }, null, 2) + '\n');
+  }
+
+  console.log('FluidCAD initialized.');
+  process.exit(0);
+}
+
+const serverEntry = resolve(__dirname, '..', 'server', 'dist', 'index.js');
+
+const server = fork(serverEntry, [], {
+  env: {
+    ...process.env,
+    FLUIDCAD_SERVER_PORT: values.port,
+    FLUIDCAD_WORKSPACE_PATH: resolve(values.workspace),
+  },
+  stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+});
+
+server.stdout.on('data', (data) => {
+  process.stdout.write(data);
+});
+
+server.stderr.on('data', (data) => {
+  process.stderr.write(data);
+});
+
+const workspacePath = resolve(values.workspace);
+let watcher;
+
+server.on('message', (msg) => {
+  if (msg.type === 'ready') {
+    console.log(`FluidCAD server ready at ${msg.url}`);
+  }
+  if (msg.type === 'init-complete') {
+    if (msg.success) {
+      console.log('FluidCAD initialized successfully.');
+      watcher = createFileWatcher(workspacePath, server);
+    } else {
+      console.error(`FluidCAD initialization failed: ${msg.error}`);
+      process.exit(1);
+    }
+  }
+});
+
+server.on('exit', (code) => {
+  process.exit(code || 0);
+});
+
+process.on('SIGINT', () => {
+  if (watcher) { watcher.close(); }
+  server.kill('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+  if (watcher) { watcher.close(); }
+  server.kill('SIGTERM');
+});

package/bin/watcher.js

@@ -0,0 +1,55 @@
+import chokidar from 'chokidar';
+import { readFileSync } from 'fs';
+
+/**
+ * Creates a file watcher that monitors .fluid.js files in the workspace
+ * and sends live-update IPC messages to the server process on changes.
+ *
+ * @param {string} workspacePath - Absolute path to the workspace directory
+ * @param {import('child_process').ChildProcess} server - The forked server process
+ * @returns {import('chokidar').FSWatcher} The watcher instance (call .close() to stop)
+ */
+export function createFileWatcher(workspacePath, server) {
+  const debounceTimers = new Map();
+
+  const watcher = chokidar.watch(workspacePath, {
+    ignored: /(^|[/\\])(node_modules|\.git)/,
+    ignoreInitial: true,
+  });
+
+  function sendUpdate(filePath) {
+    try {
+      const code = readFileSync(filePath, 'utf-8');
+      server.send({
+        type: 'live-update',
+        fileName: filePath,
+        code,
+      });
+      console.log(`File changed: ${filePath}`);
+    } catch (err) {
+      console.error(`Failed to read ${filePath}:`, err.message);
+    }
+  }
+
+  function onFileChange(filePath) {
+    if (!filePath.endsWith('.fluid.js')) {
+      return;
+    }
+
+    if (debounceTimers.has(filePath)) {
+      clearTimeout(debounceTimers.get(filePath));
+    }
+
+    debounceTimers.set(filePath, setTimeout(() => {
+      debounceTimers.delete(filePath);
+      sendUpdate(filePath);
+    }, 300));
+  }
+
+  watcher.on('change', onFileChange);
+  watcher.on('add', onFileChange);
+
+  console.log(`Watching for .fluid.js changes in ${workspacePath}`);
+
+  return watcher;
+}

package/lib/dist/common/edge.d.ts

@@ -0,0 +1,14 @@
+import { ShapeType } from "./shape-type.js";
+import type { TopoDS_Edge } from "occjs-wrapper";
+import { Shape } from "./shape.js";
+import { Vertex } from "./vertex.js";
+export declare class Edge extends Shape<TopoDS_Edge> {
+    constructor(edge: TopoDS_Edge);
+    getType(): ShapeType;
+    isEdge(): boolean;
+    getSubShapes(type: ShapeType): Shape[];
+    getFirstVertex(): Vertex;
+    getLastVertex(): Vertex;
+    isClosed(): boolean;
+    static fromTopoDSEdge(edge: TopoDS_Edge): Edge;
+}

package/lib/dist/common/edge.js

@@ -0,0 +1,32 @@
+import { Shape } from "./shape.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+import { Vertex } from "./vertex.js";
+export class Edge extends Shape {
+    constructor(edge) {
+        super(edge);
+    }
+    getType() {
+        return "edge";
+    }
+    isEdge() {
+        return true;
+    }
+    getSubShapes(type) {
+        if (type === 'edge') {
+            return [this];
+        }
+        return [];
+    }
+    getFirstVertex() {
+        return Vertex.fromTopoDSVertex(EdgeOps.getFirstVertexRaw(this.getShape()));
+    }
+    getLastVertex() {
+        return Vertex.fromTopoDSVertex(EdgeOps.getLastVertexRaw(this.getShape()));
+    }
+    isClosed() {
+        return EdgeOps.isClosed(this);
+    }
+    static fromTopoDSEdge(edge) {
+        return new Edge(edge);
+    }
+}

package/lib/dist/common/face.d.ts

@@ -0,0 +1,31 @@
+import type { TopoDS_Edge, TopoDS_Face } from "occjs-wrapper";
+import { BoundingBox } from "../helpers/types.js";
+import { ShapeType } from "./shape-type.js";
+import { Wire } from "./wire.js";
+import { Point } from "../math/point.js";
+import { Plane } from "../math/plane.js";
+import { Shape } from "./shape.js";
+import { Edge } from "./edge.js";
+import { Vector3d } from "../math/vector3d.js";
+export declare class Face extends Shape<TopoDS_Face> {
+    protected normal: Vector3d;
+    protected boundingBox: BoundingBox;
+    private edges;
+    private wires;
+    constructor(face: TopoDS_Face);
+    getType(): ShapeType;
+    isFace(): boolean;
+    getSubShapes(type: ShapeType): Shape[];
+    getEdges(): Edge[];
+    getWires(): Wire[];
+    hasEdge(edge: TopoDS_Edge): Edge;
+    getNormal(): Vector3d;
+    getBoundingBox(): BoundingBox;
+    center(): Point;
+    static fromTopoDSFace(face: TopoDS_Face): Face;
+    getPlane(): Plane;
+    getFaces(): TopoDS_Face[];
+    calculateNormal(): Vector3d;
+    compareTo(other: Face): boolean;
+    serialize(): {};
+}

package/lib/dist/common/face.js

@@ -0,0 +1,83 @@
+import { Explorer } from "../oc/explorer.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Point } from "../math/point.js";
+import { Shape } from "./shape.js";
+export class Face extends Shape {
+    normal = null;
+    boundingBox = null;
+    edges = null;
+    wires = null;
+    constructor(face) {
+        super(face);
+    }
+    getType() {
+        return "face";
+    }
+    isFace() {
+        return true;
+    }
+    getSubShapes(type) {
+        if (type === 'face') {
+            return [this];
+        }
+        else if (type === 'edge') {
+            return this.getEdges();
+        }
+        return [];
+    }
+    getEdges() {
+        if (this.edges) {
+            return this.edges;
+        }
+        const wires = this.getWires();
+        this.edges = wires.flatMap(w => w.getEdges());
+        return this.edges;
+    }
+    getWires() {
+        if (this.wires) {
+            return this.wires;
+        }
+        this.wires = Explorer.findWiresWrapped(this);
+        return this.wires;
+    }
+    hasEdge(edge) {
+        const edges = this.getEdges();
+        return edges.find(e => e.getShape().IsPartner(edge)) || null;
+    }
+    getNormal() {
+        return this.normal;
+    }
+    getBoundingBox() {
+        if (this.boundingBox) {
+            return this.boundingBox;
+        }
+        this.boundingBox = ShapeOps.getBoundingBox(this.getShape());
+        return this.boundingBox;
+    }
+    center() {
+        const bbox = this.getBoundingBox();
+        return new Point((bbox.minX + bbox.maxX) / 2, (bbox.minY + bbox.maxY) / 2, (bbox.minZ + bbox.maxZ) / 2);
+    }
+    static fromTopoDSFace(face) {
+        return new Face(face);
+    }
+    getPlane() {
+        return FaceOps.getPlane(this.getShape());
+    }
+    getFaces() {
+        return [this.getShape()];
+    }
+    calculateNormal() {
+        return FaceOps.calculateNormal(this.getShape());
+    }
+    compareTo(other) {
+        if (!(other instanceof Face)) {
+            return false;
+        }
+        return this.getShape().IsPartner(other.getShape());
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/common/materials.d.ts

@@ -0,0 +1,7 @@
+export type Material = {
+    name: string;
+    density: number;
+    densityUnit: string;
+};
+export declare const MATERIALS: Material[];
+export declare function getMaterials(): Material[];

package/lib/dist/common/materials.js

@@ -0,0 +1,22 @@
+export const MATERIALS = [
+    { name: 'Steel (AISI 1020)', density: 7.87, densityUnit: 'g/cm³' },
+    { name: 'Stainless Steel (304)', density: 8.00, densityUnit: 'g/cm³' },
+    { name: 'Aluminum 6061', density: 2.70, densityUnit: 'g/cm³' },
+    { name: 'Aluminum 1060', density: 2.81, densityUnit: 'g/cm³' },
+    { name: 'Aluminum 7075', density: 2.81, densityUnit: 'g/cm³' },
+    { name: 'Brass (C260)', density: 8.53, densityUnit: 'g/cm³' },
+    { name: 'Copper', density: 8.96, densityUnit: 'g/cm³' },
+    { name: 'Titanium Ti-6Al-4V', density: 4.43, densityUnit: 'g/cm³' },
+    { name: 'Cast Iron (Gray)', density: 7.15, densityUnit: 'g/cm³' },
+    { name: 'Bronze', density: 8.73, densityUnit: 'g/cm³' },
+    { name: 'Polycarbonate (PC)', density: 1.20, densityUnit: 'g/cm³' },
+    { name: 'ABS Plastic', density: 1.05, densityUnit: 'g/cm³' },
+    { name: 'PLA', density: 1.24, densityUnit: 'g/cm³' },
+    { name: 'Nylon (PA6)', density: 1.14, densityUnit: 'g/cm³' },
+    { name: 'Carbon Fiber Composite', density: 1.55, densityUnit: 'g/cm³' },
+    { name: 'Wood (Pine)', density: 0.53, densityUnit: 'g/cm³' },
+    { name: 'Plain Carbon Steel', density: 0.098, densityUnit: 'lbs/in³' },
+];
+export function getMaterials() {
+    return MATERIALS;
+}

package/lib/dist/common/scene-object.d.ts

@@ -0,0 +1,111 @@
+import { Shape, ShapeFilter } from "./shape.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { ISceneObject } from "../core/interfaces.js";
+import { FusionScope, OperationMode } from "../features/extrude-options.js";
+import { ShapeType } from "./shape-type.js";
+export type SourceLocation = {
+    filePath: string;
+    line: number;
+    column: number;
+};
+export interface Comparable<T> {
+    compareTo(other: T): boolean;
+}
+export interface Serializable {
+    serialize(): any;
+}
+export type BuildSceneObjectContext = {
+    getSceneObjects(): SceneObject[];
+    getActiveSceneObjects(): SceneObject[];
+    getSceneObjectsFromTo(obj: SceneObject, to: SceneObject, type?: string): SceneObject[];
+    getTransform(): Matrix4 | null;
+    getLastObject(): SceneObject | null;
+};
+export declare abstract class SceneObject implements Comparable<SceneObject>, Serializable, ISceneObject {
+    private state;
+    private children;
+    private _id;
+    private _order;
+    private _transform;
+    private _parent;
+    private _alwaysVisible;
+    private _name;
+    private _guide;
+    private _sourceLocation;
+    private _error;
+    protected _fusionScope?: FusionScope;
+    protected _operationMode: OperationMode;
+    protected _symmetric: boolean;
+    constructor();
+    get id(): string;
+    get parentId(): string | null;
+    private setParent;
+    protected setAlwaysVisible(): void;
+    isAlwaysVisible(): boolean;
+    hasShapes(): boolean;
+    addChildObject(child: SceneObject): void;
+    getChildren(): SceneObject[];
+    getParent(): SceneObject | null;
+    getPreviousSibling(obj: SceneObject): SceneObject | null;
+    getPreviousSiblings(obj: SceneObject): SceneObject[];
+    isContainer(): boolean;
+    saveShapesSnapshot(context: BuildSceneObjectContext): void;
+    getSnapshot(): Map<SceneObject, Shape[]>;
+    abstract serialize(): any;
+    abstract getType(): string;
+    abstract build(context?: BuildSceneObjectContext): void;
+    compareTo(other: SceneObject): boolean;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    clone(): SceneObject[];
+    setTransform(matrix: Matrix4): void;
+    getTransform(): Matrix4 | null;
+    getTransformMatrix(): Matrix4 | null;
+    isExtrudable(): boolean;
+    init(): void;
+    private get addedShapes();
+    private set addedShapes(value);
+    private get removedShapes();
+    private set removedShapes(value);
+    getUniqueType(): string;
+    addShape(shape: Shape): void;
+    addShapes(shapes: Shape[]): void;
+    removeShape(shape: Shape, removedBy: SceneObject): void;
+    removeShapes(removedBy: SceneObject): void;
+    getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
+    getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
+    getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
+    getAddedShapes(): Shape[];
+    getRemovedShapes(): {
+        shape: Shape;
+        removedBy: SceneObject;
+    }[];
+    getFullState(): Map<string, any>;
+    restoreState(state: Map<string, any>): void;
+    setState(key: string, value: any): void;
+    getState(key: string): any;
+    setOrder(order: number): void;
+    getOrder(): number;
+    getName(): string;
+    name(value: string): this;
+    guide(): this;
+    setSourceLocation(loc: SourceLocation): void;
+    getSourceLocation(): SourceLocation | null;
+    setError(message: string): void;
+    clearError(): void;
+    getError(): string | null;
+    getFusionScope(): FusionScope | undefined;
+    getOperationMode(): OperationMode;
+    isSymmetric(): boolean;
+    resolveFusionScope(sceneObjects: SceneObject[]): SceneObject[];
+    add(...objects: ISceneObject[]): this;
+    new(): this;
+    remove(...objects: ISceneObject[]): this;
+    symmetric(): this;
+    /**
+     * Called after all objects have been built. Override to perform
+     * cleanup that depends on knowing the final scene state.
+     */
+    clean(allObjects: SceneObject[]): void;
+    protected generateUniqueName(suffix: string): string;
+}