fluidcad 0.0.2

package/lib/dist/common/scene-object.js

@@ -0,0 +1,380 @@
+import { randomUUID } from "crypto";
+export class SceneObject {
+    state;
+    children = [];
+    _id;
+    _order = 0;
+    _transform = null;
+    _parent = null;
+    _alwaysVisible = false;
+    _name = '';
+    _guide = false;
+    _sourceLocation = null;
+    _error = null;
+    _fusionScope = 'all';
+    _operationMode = 'add';
+    _symmetric = false;
+    constructor() {
+        this.state = new Map();
+        this.state.set('addedShapes', []);
+        this.state.set('removedShapes', []);
+        this._id = randomUUID().toString();
+        this._name = this.getType();
+    }
+    get id() {
+        return this._id;
+    }
+    get parentId() {
+        return this._parent?.id || null;
+    }
+    setParent(parent) {
+        this._parent = parent;
+    }
+    setAlwaysVisible() {
+        this._alwaysVisible = true;
+    }
+    isAlwaysVisible() {
+        return this._alwaysVisible;
+    }
+    hasShapes() {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                const ownShapes = child.getOwnShapes();
+                if (ownShapes.length > 0) {
+                    return true;
+                }
+            }
+        }
+        return this.getOwnShapes().length > 0;
+    }
+    addChildObject(child) {
+        this.children.push(child);
+        child.setParent(this);
+    }
+    getChildren() {
+        return this.children;
+    }
+    getParent() {
+        return this._parent;
+    }
+    getPreviousSibling(obj) {
+        const children = this.getChildren();
+        const index = children.indexOf(obj);
+        if (index > 0) {
+            return children[index - 1];
+        }
+        return null;
+    }
+    getPreviousSiblings(obj) {
+        const children = this.getChildren();
+        const index = children.indexOf(obj);
+        if (index > 0) {
+            return children.slice(0, index);
+        }
+        return [];
+    }
+    isContainer() {
+        return false;
+    }
+    // called by containers to save the shapes state up to this object
+    saveShapesSnapshot(context) {
+        const upToHere = context.getSceneObjects();
+        const map = new Map();
+        for (const obj of upToHere) {
+            map.set(obj, obj.getShapes());
+        }
+        this.setState('snapshot', map);
+    }
+    getSnapshot() {
+        return this.getState('snapshot') || [];
+    }
+    compareTo(other) {
+        const match = this._guide === other._guide;
+        if (!match) {
+            return false;
+        }
+        if (this._operationMode !== other._operationMode) {
+            return false;
+        }
+        if (this._symmetric !== other._symmetric) {
+            return false;
+        }
+        if (typeof (this._fusionScope) !== typeof (other._fusionScope)) {
+            return false;
+        }
+        if (typeof (this._fusionScope) === 'string' && typeof (other._fusionScope) === 'string') {
+            return this._fusionScope === other._fusionScope;
+        }
+        if (this._fusionScope instanceof SceneObject && other._fusionScope instanceof SceneObject) {
+            return this._fusionScope.compareTo(other._fusionScope);
+        }
+        const thisScope = this._fusionScope;
+        const otherScope = other._fusionScope;
+        if (thisScope.length !== otherScope.length) {
+            return false;
+        }
+        for (let i = 0; i < thisScope.length; i++) {
+            if (!thisScope[i].compareTo(otherScope[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        throw new Error("createCopy() not implemented for " + this.getType());
+    }
+    clone() {
+        const visited = new Set();
+        const ordered = [];
+        const collect = (obj) => {
+            if (visited.has(obj)) {
+                return;
+            }
+            visited.add(obj);
+            for (const dep of obj.getDependencies()) {
+                collect(dep);
+            }
+            ordered.push(obj);
+            for (const child of obj.getChildren()) {
+                collect(child);
+            }
+        };
+        collect(this);
+        const remap = new Map();
+        const result = [];
+        for (const obj of ordered) {
+            const copy = obj.createCopy(remap);
+            remap.set(obj, copy);
+            result.push(copy);
+            const parent = obj.getParent();
+            if (parent && remap.has(parent)) {
+                remap.get(parent).addChildObject(copy);
+            }
+        }
+        return result;
+    }
+    setTransform(matrix) {
+        this._transform = matrix;
+    }
+    getTransform() {
+        return this._transform;
+    }
+    getTransformMatrix() {
+        return null;
+    }
+    isExtrudable() {
+        return false;
+    }
+    init() {
+    }
+    get addedShapes() {
+        return this.state.get('addedShapes');
+    }
+    set addedShapes(shapes) {
+        this.state.set('addedShapes', shapes);
+    }
+    get removedShapes() {
+        return this.state.get('removedShapes');
+    }
+    set removedShapes(shapes) {
+        this.state.set('removedShapes', shapes);
+    }
+    getUniqueType() {
+        return this.getType();
+    }
+    addShape(shape) {
+        if (this._guide) {
+            shape.markAsGuide();
+        }
+        this.addedShapes.push(shape);
+    }
+    addShapes(shapes) {
+        for (const shape of shapes) {
+            this.addShape(shape);
+        }
+    }
+    removeShape(shape, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                const childShapes = child.getShapes();
+                if (childShapes.some(s => s === shape)) {
+                    child.removeShape(shape, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedShapes.push({
+            shape,
+            removedBy
+        });
+    }
+    removeShapes(removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                child.removeShapes(removedBy);
+            }
+            return;
+        }
+        for (const shape of this.addedShapes) {
+            this.removeShape(shape, removedBy);
+        }
+    }
+    getOwnShapes(filter, scope) {
+        filter = {
+            excludeMeta: filter?.excludeMeta ?? true,
+            excludeGuide: filter?.excludeGuide ?? true,
+        };
+        const shapes = this.addedShapes.filter(s => !this.removedShapes.find(r => r.shape === s && (!scope || scope.has(r.removedBy))));
+        let filteredShapes = shapes;
+        if (filter?.excludeMeta) {
+            filteredShapes = filteredShapes.filter(s => !s.isMetaShape());
+        }
+        if (filter?.excludeGuide) {
+            filteredShapes = filteredShapes.filter(s => !s.isGuideShape());
+        }
+        return filteredShapes;
+    }
+    getChildShapes(filter, type) {
+        let shapes = [];
+        filter = {
+            excludeMeta: filter?.excludeMeta ?? true,
+            excludeGuide: filter?.excludeGuide ?? true,
+        };
+        for (const child of this.children) {
+            shapes = shapes.concat(child.getShapes(filter, type));
+        }
+        return shapes;
+    }
+    getShapes(filter, type) {
+        filter = {
+            excludeMeta: filter?.excludeMeta ?? true,
+            excludeGuide: filter?.excludeGuide ?? true,
+        };
+        if (this.isContainer()) {
+            return this.getChildShapes(filter, type);
+        }
+        const ownShapes = this.getOwnShapes(filter);
+        if (type) {
+            return ownShapes.filter(s => s.getType() === type);
+        }
+        return ownShapes;
+    }
+    getAddedShapes() {
+        return this.addedShapes;
+    }
+    getRemovedShapes() {
+        return this.removedShapes;
+    }
+    getFullState() {
+        return this.state;
+    }
+    restoreState(state) {
+        this.state = state;
+    }
+    setState(key, value) {
+        this.state.set(key, value);
+    }
+    getState(key) {
+        return this.state.get(key);
+    }
+    setOrder(order) {
+        this._order = order;
+    }
+    getOrder() {
+        return this._order;
+    }
+    getName() {
+        return this._name;
+    }
+    name(value) {
+        this._name = value;
+        return this;
+    }
+    guide() {
+        this._guide = true;
+        return this;
+    }
+    setSourceLocation(loc) {
+        this._sourceLocation = loc;
+    }
+    getSourceLocation() {
+        return this._sourceLocation;
+    }
+    setError(message) {
+        this._error = message;
+    }
+    clearError() {
+        this._error = null;
+    }
+    getError() {
+        return this._error;
+    }
+    getFusionScope() {
+        return this._fusionScope || 'all';
+    }
+    getOperationMode() {
+        return this._operationMode;
+    }
+    isSymmetric() {
+        return this._symmetric;
+    }
+    resolveFusionScope(sceneObjects) {
+        const scope = this.getFusionScope();
+        if (scope === 'none') {
+            return [];
+        }
+        else if (scope instanceof SceneObject) {
+            return [scope];
+        }
+        else if (Array.isArray(scope)) {
+            return scope;
+        }
+        return sceneObjects;
+    }
+    add(...objects) {
+        this._operationMode = 'add';
+        if (objects.length === 0) {
+            this._fusionScope = 'all';
+        }
+        else if (objects.length === 1) {
+            this._fusionScope = objects[0];
+        }
+        else {
+            this._fusionScope = objects;
+        }
+        return this;
+    }
+    new() {
+        this._operationMode = 'new';
+        this._fusionScope = 'none';
+        return this;
+    }
+    remove(...objects) {
+        this._operationMode = 'remove';
+        if (objects.length === 0) {
+            this._fusionScope = 'all';
+        }
+        else if (objects.length === 1) {
+            this._fusionScope = objects[0];
+        }
+        else {
+            this._fusionScope = objects;
+        }
+        return this;
+    }
+    symmetric() {
+        this._symmetric = true;
+        return this;
+    }
+    /**
+     * Called after all objects have been built. Override to perform
+     * cleanup that depends on knowing the final scene state.
+     */
+    clean(allObjects) { }
+    generateUniqueName(suffix) {
+        return `${this.getOrder()}-${this.getUniqueType()}-${suffix}`;
+    }
+}

package/lib/dist/common/shape-factory.d.ts

@@ -0,0 +1,8 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Solid } from "./solid.js";
+import { Wire } from "./wire.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export declare class ShapeFactory {
+    static fromShape(shape: TopoDS_Shape): Solid | Edge | Face | Wire;
+}

package/lib/dist/common/shape-factory.js

@@ -0,0 +1,31 @@
+import { Explorer } from "../oc/explorer.js";
+import { Solid } from "./solid.js";
+import { Wire } from "./wire.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export class ShapeFactory {
+    static fromShape(shape) {
+        if (Explorer.isSolid(shape)) {
+            return Solid.fromTopoDSSolid(Explorer.toSolid(shape));
+        }
+        if (Explorer.isWire(shape)) {
+            return Wire.fromTopoDSWire(Explorer.toWire(shape));
+        }
+        if (Explorer.isFace(shape)) {
+            return Face.fromTopoDSFace(Explorer.toFace(shape));
+        }
+        if (Explorer.isEdge(shape)) {
+            return Edge.fromTopoDSEdge(Explorer.toEdge(shape));
+        }
+        if (Explorer.isCompound(shape) || Explorer.isCompoundSolid(shape)) {
+            const solids = Explorer.findShapes(shape, Explorer.getOcShapeType("solid"));
+            if (solids.length === 1) {
+                return Solid.fromTopoDSSolid(Explorer.toSolid(solids[0]));
+            }
+            if (solids.length > 1) {
+                return Solid.fromTopoDSSolid(Explorer.toSolid(solids[0]));
+            }
+        }
+        throw new Error("Unknown shape type");
+    }
+}

package/lib/dist/common/shape-type.d.ts

@@ -0,0 +1 @@
+export type ShapeType = "vertex" | "edge" | "wire" | "face" | "solid" | "shell" | "compound";

package/lib/dist/common/shape-type.js

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

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

@@ -0,0 +1,43 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { ShapeType } from "./shape-type.js";
+import { SceneObjectMesh } from "../rendering/scene.js";
+export interface ShapeFilter {
+    excludeMeta?: boolean;
+    excludeGuide?: boolean;
+}
+export declare abstract class Shape<T extends TopoDS_Shape = TopoDS_Shape> {
+    private shape;
+    isMetaShapeFlag: boolean;
+    isGuideFlag: boolean;
+    metaType?: string;
+    metaData?: Record<string, any>;
+    id: string;
+    colorMap: Array<{
+        shape: TopoDS_Shape;
+        color: string;
+    }>;
+    private meshes;
+    constructor(shape: T);
+    abstract getType(): ShapeType;
+    getShape(): T;
+    abstract getSubShapes(type: ShapeType): Shape[];
+    isSame(other: Shape): boolean;
+    isPartner(other: Shape): boolean;
+    isEqual(other: Shape): boolean;
+    isSolid(): boolean;
+    isFace(): boolean;
+    isEdge(): boolean;
+    isWire(): boolean;
+    isVertex(): boolean;
+    dispose(): void;
+    markAsMetaShape(type?: string): void;
+    markAsGuide(): void;
+    isMetaShape(): boolean;
+    isGuideShape(): boolean;
+    getMeshes(): SceneObjectMesh[];
+    setMeshes(meshes: SceneObjectMesh[]): void;
+    setColor(face: TopoDS_Shape, color: string): void;
+    getColor(face: TopoDS_Shape): string | undefined;
+    hasColors(): boolean;
+    copy(): Shape;
+}

package/lib/dist/common/shape.js

@@ -0,0 +1,95 @@
+import { randomUUID } from "crypto";
+export class Shape {
+    shape;
+    isMetaShapeFlag = false;
+    isGuideFlag = false;
+    metaType;
+    metaData;
+    id;
+    colorMap = [];
+    meshes;
+    constructor(shape) {
+        this.shape = shape;
+        this.id = randomUUID();
+    }
+    getShape() {
+        return this.shape;
+    }
+    isSame(other) {
+        if (!(other instanceof Shape)) {
+            return false;
+        }
+        return this.getShape().IsSame(other.getShape());
+    }
+    isPartner(other) {
+        if (!(other instanceof Shape)) {
+            return false;
+        }
+        return this.getShape().IsPartner(other.getShape());
+    }
+    isEqual(other) {
+        if (!(other instanceof Shape)) {
+            return false;
+        }
+        return this.getShape().IsEqual(other.getShape());
+    }
+    isSolid() {
+        return false;
+    }
+    isFace() {
+        return false;
+    }
+    isEdge() {
+        return false;
+    }
+    isWire() {
+        return false;
+    }
+    isVertex() {
+        return false;
+    }
+    dispose() {
+        this.shape?.delete();
+    }
+    markAsMetaShape(type) {
+        this.isMetaShapeFlag = true;
+        this.metaType = type;
+    }
+    markAsGuide() {
+        this.isGuideFlag = true;
+    }
+    isMetaShape() {
+        return this.isMetaShapeFlag;
+    }
+    isGuideShape() {
+        return this.isGuideFlag;
+    }
+    getMeshes() {
+        return this.meshes;
+    }
+    setMeshes(meshes) {
+        this.meshes = meshes;
+    }
+    setColor(face, color) {
+        if (this.isEdge()) {
+            throw new Error("Cannot set color on edge shape");
+        }
+        if (this.isWire()) {
+            throw new Error("Cannot set color on wire shape");
+        }
+        if (this.isVertex()) {
+            throw new Error("Cannot set color on vertex shape");
+        }
+        this.colorMap.push({ shape: face, color });
+    }
+    getColor(face) {
+        const entry = this.colorMap.find(c => c.shape.IsSame(face));
+        return entry?.color;
+    }
+    hasColors() {
+        return this.colorMap.length > 0;
+    }
+    copy() {
+        throw new Error("Copy method not implemented for shape type: " + this.getType());
+    }
+}

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

@@ -0,0 +1,6 @@
+export { Shape } from "./shape.js";
+export { Edge } from "./edge.js";
+export { Vertex } from "./vertex.js";
+export { Face } from "./face.js";
+export { Solid } from "./solid.js";
+export { SolidFace } from "./solid-face.js";

package/lib/dist/common/shapes.js

@@ -0,0 +1,6 @@
+export { Shape } from "./shape.js";
+export { Edge } from "./edge.js";
+export { Vertex } from "./vertex.js";
+export { Face } from "./face.js";
+export { Solid } from "./solid.js";
+export { SolidFace } from "./solid-face.js";

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

@@ -0,0 +1,9 @@
+import type { TopoDS_Face, TopoDS_Solid } from "occjs-wrapper";
+import { Face } from "./face.js";
+export declare class SolidFace extends Face {
+    private solid;
+    private face;
+    constructor(solid: TopoDS_Solid, face: TopoDS_Face);
+    setNormal(): void;
+    static fromTopoDSSolidAndFace(solid: TopoDS_Solid, face: TopoDS_Face): Face;
+}

package/lib/dist/common/solid-face.js

@@ -0,0 +1,22 @@
+import { ShapeOps } from "../oc/shape-ops.js";
+import { FaceQuery } from "../oc/face-query.js";
+import { Face } from "./face.js";
+export class SolidFace extends Face {
+    solid;
+    face;
+    constructor(solid, face) {
+        super(face);
+        this.solid = solid;
+        this.face = face;
+        this.setNormal();
+    }
+    setNormal() {
+        if (!FaceQuery.isPlanarFaceRaw(this.face)) {
+            return;
+        }
+        this.normal = ShapeOps.getSolidOutwardNormalRaw(this.face, this.solid);
+    }
+    static fromTopoDSSolidAndFace(solid, face) {
+        return new SolidFace(solid, face);
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { TopoDS_Edge, TopoDS_Face, TopoDS_Solid } from "occjs-wrapper";
+import { ShapeType } from "./shape-type.js";
+import { Shape } from "./shape.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export declare class Solid extends Shape<TopoDS_Solid> {
+    private faces;
+    private edges;
+    constructor(solid: TopoDS_Solid);
+    getType(): ShapeType;
+    isSolid(): boolean;
+    getSubShapes(type: ShapeType): Shape[];
+    getEdges(): Edge[];
+    getFaces(): Face[];
+    getFace(face: TopoDS_Face): Face | null;
+    hasFace(face: TopoDS_Face): boolean;
+    hasEdge(edge: TopoDS_Edge): TopoDS_Edge;
+    copy(): Shape;
+    static fromTopoDSSolid(solid: TopoDS_Solid): Solid;
+}

package/lib/dist/common/solid.js

@@ -0,0 +1,68 @@
+import { Explorer } from "../oc/explorer.js";
+import { Shape } from "./shape.js";
+export class Solid extends Shape {
+    faces = null;
+    edges = null;
+    constructor(solid) {
+        super(solid);
+    }
+    getType() {
+        return "solid";
+    }
+    isSolid() {
+        return true;
+    }
+    getSubShapes(type) {
+        if (type === "face") {
+            return this.getFaces();
+        }
+        else if (type === "edge") {
+            return this.getEdges();
+        }
+        return [];
+    }
+    getEdges() {
+        if (this.edges) {
+            return this.edges;
+        }
+        this.edges = Explorer.findEdgesWrapped(this);
+        return this.edges;
+    }
+    getFaces() {
+        if (this.faces) {
+            return this.faces;
+        }
+        this.faces = Explorer.findFacesWrapped(this);
+        return this.faces;
+    }
+    getFace(face) {
+        const faces = this.getFaces();
+        return faces.find(f => f.getShape().IsPartner(face)) || null;
+    }
+    hasFace(face) {
+        const faces = this.getFaces();
+        for (const f of faces) {
+            const tpFace = f.getShape();
+            if (tpFace.IsSame(face)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasEdge(edge) {
+        const edges = this.getEdges();
+        for (const e of edges) {
+            const tpEdge = e.getShape();
+            if (tpEdge.IsSame(edge)) {
+                return tpEdge;
+            }
+        }
+        return null;
+    }
+    copy() {
+        return new Solid(this.getShape());
+    }
+    static fromTopoDSSolid(solid) {
+        return new Solid(solid);
+    }
+}