fluidcad 0.0.2

package/lib/dist/features/axis-mid.js

@@ -0,0 +1,59 @@
+import { Axis } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class AxisMiddle extends AxisObjectBase {
+    axis1;
+    axis2;
+    options;
+    constructor(axis1, axis2, options) {
+        super();
+        this.axis1 = axis1;
+        this.axis2 = axis2;
+        this.options = options;
+    }
+    build() {
+        let axis1 = this.axis1.getAxis();
+        let axis2 = this.axis2.getAxis();
+        console.log("AxisMiddle: Retrieved axes:", axis1, axis2);
+        const parallel = axis1.isParallelTo(axis2);
+        if (!parallel) {
+            throw new Error("AxisMiddleRenderable: The two axes are not parallel; cannot define a middle axis");
+        }
+        const middlePoint = axis1.origin.add(axis2.origin).multiplyScalar(0.5);
+        let middleAxis = new Axis(middlePoint, axis1.direction);
+        if (this.options) {
+            middleAxis = middleAxis.transform(this.options);
+        }
+        this.setState('axis', middleAxis);
+        const edge = EdgeOps.axisToEdge(middleAxis);
+        this.addShape(edge);
+    }
+    compareTo(other) {
+        if (!(other instanceof AxisMiddle)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.axis1.compareTo(other.axis1)) {
+            return false;
+        }
+        if (!this.axis2.compareTo(other.axis2)) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'axis-middle';
+    }
+    serialize() {
+        return {
+            axis1: this.axis1.serialize(),
+            axis2: this.axis2.serialize(),
+            options: this.options
+        };
+    }
+}

package/lib/dist/features/axis-renderable-base.d.ts

@@ -0,0 +1,8 @@
+import { Axis } from "../math/axis.js";
+import { SceneObject } from "../common/scene-object.js";
+import { IAxis } from "../core/interfaces.js";
+export declare abstract class AxisObjectBase extends SceneObject implements IAxis {
+    constructor();
+    getAxis(): Axis;
+    getType(): string;
+}

package/lib/dist/features/axis-renderable-base.js

@@ -0,0 +1,12 @@
+import { SceneObject } from "../common/scene-object.js";
+export class AxisObjectBase extends SceneObject {
+    constructor() {
+        super();
+    }
+    getAxis() {
+        return this.getState('axis');
+    }
+    getType() {
+        return 'axis';
+    }
+}

package/lib/dist/features/axis.d.ts

@@ -0,0 +1,14 @@
+import { Axis, AxisTransformOptions } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export declare class AxisObject extends AxisObjectBase {
+    axis: Axis;
+    private options?;
+    constructor(axis: Axis, options?: AxisTransformOptions);
+    build(): void;
+    compareTo(other: AxisObject): boolean;
+    serialize(): {
+        origin: import("../math/point.js").Point;
+        direction: import("../math/vector3d.js").Vector3d;
+        options: AxisTransformOptions;
+    };
+}

package/lib/dist/features/axis.js

@@ -0,0 +1,43 @@
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+export class AxisObject extends AxisObjectBase {
+    axis;
+    options;
+    constructor(axis, options) {
+        super();
+        this.axis = axis;
+        this.options = options;
+        let a = this.axis;
+        if (this.options) {
+            a = a.transform(this.options);
+        }
+        this.setState('axis', a);
+    }
+    build() {
+        const edge = EdgeOps.axisToEdge(this.getAxis());
+        edge.markAsMetaShape();
+        this.addShape(edge);
+    }
+    compareTo(other) {
+        if (!(other instanceof AxisObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.axis.equals(other.axis)) {
+            return false;
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    serialize() {
+        return {
+            origin: this.axis.origin,
+            direction: this.axis.direction,
+            options: this.options
+        };
+    }
+}

package/lib/dist/features/chamfer.d.ts

@@ -0,0 +1,20 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+export declare class Chamfer extends SceneObject {
+    private distance;
+    private distance2;
+    private isAngle;
+    private _selection;
+    constructor(distance: number, distance2: number, isAngle?: boolean, selection?: SceneObject);
+    get selection(): SceneObject;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SceneObject): boolean;
+    getType(): string;
+    serialize(): {
+        edges: any;
+        distance: number;
+        distance2: number;
+        isAngle: boolean;
+    };
+}

package/lib/dist/features/chamfer.js

@@ -0,0 +1,129 @@
+import { SceneObject } from "../common/scene-object.js";
+import { FilletOps } from "../oc/fillet-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Chamfer extends SceneObject {
+    distance;
+    distance2;
+    isAngle;
+    _selection = null;
+    constructor(distance, distance2, isAngle = false, selection) {
+        super();
+        this.distance = distance;
+        this.distance2 = distance2;
+        this.isAngle = isAngle;
+        this._selection = selection ?? null;
+    }
+    get selection() {
+        return this._selection;
+    }
+    build(context) {
+        let sceneObjects;
+        sceneObjects = new Map();
+        for (const obj of context.getSceneObjects()) {
+            const shapes = obj.getShapes({}, 'solid');
+            if (shapes.length) {
+                sceneObjects.set(obj, shapes);
+            }
+        }
+        const allEdgeShapes = this.selection.getShapes();
+        let edges = allEdgeShapes;
+        const newShapes = [];
+        const shapeObjectMap = new Map();
+        for (const [obj, shapes] of sceneObjects) {
+            if (obj.id === this.parentId) {
+                continue;
+            }
+            for (const shape of shapes) {
+                console.log('Chamfer: Mapping shape to object:', shape.getType(), obj.id);
+                shapeObjectMap.set(shape, obj);
+            }
+        }
+        const allTargetShapes = Array.from(shapeObjectMap.keys());
+        console.log('Chamfer: All target shapes count:', allTargetShapes.length);
+        console.log('Fillet: Target shapes count:', allTargetShapes.length);
+        for (const shape of allTargetShapes) {
+            const solid = shape;
+            console.log('Chamfer: Processing solid:', solid.getType(), solid.id);
+            const targetEdges = edges.filter(e => solid.hasEdge(e.getShape()));
+            console.log('Fillet: Target edges count:', targetEdges.length);
+            if (!targetEdges.length) {
+                continue;
+            }
+            edges = edges.filter(e => !targetEdges.includes(e));
+            try {
+                let newShape;
+                if (!this.distance2) {
+                    newShape = FilletOps.makeChamfer(solid, targetEdges, this.distance);
+                }
+                else {
+                    const faces = solid.getFaces();
+                    const commonFaces = [];
+                    for (const edge of targetEdges) {
+                        const firstCommonFace = faces.find(f => f.hasEdge(edge.getShape()));
+                        if (!firstCommonFace) {
+                            newShapes.push(shape);
+                            console.error("Chamfer: Failed to find common face for chamfer.");
+                            continue;
+                        }
+                        commonFaces.push(firstCommonFace);
+                    }
+                    newShape = FilletOps.makeChamferTwoDistances(solid, targetEdges, this.distance, this.distance2, commonFaces, this.isAngle);
+                }
+                const obj = shapeObjectMap.get(shape);
+                obj.removeShape(shape, this);
+                const subShapes = Explorer.findSolidsWrapped(ShapeOps.cleanShape(newShape));
+                for (const subShape of subShapes) {
+                    newShapes.push(subShape);
+                }
+            }
+            catch {
+                console.error("Fillet: Failed to create chamfer.");
+                continue;
+            }
+        }
+        this.selection.removeShapes(this);
+        this.addShapes(newShapes);
+    }
+    getDependencies() {
+        return this.selection ? [this.selection] : [];
+    }
+    createCopy(remap) {
+        const selection = this.selection
+            ? (remap.get(this.selection) || this.selection)
+            : undefined;
+        return new Chamfer(this.distance, this.distance2, this.isAngle, selection);
+    }
+    compareTo(other) {
+        if (!(other instanceof Chamfer)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.distance !== other.distance) {
+            return false;
+        }
+        if (this.distance2 !== other.distance2) {
+            return false;
+        }
+        if (this.isAngle !== other.isAngle) {
+            return false;
+        }
+        if (!this.selection.compareTo(other.selection)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "chamfer";
+    }
+    serialize() {
+        return {
+            edges: this.selection.serialize(),
+            distance: this.distance,
+            distance2: this.distance2,
+            isAngle: this.isAngle
+        };
+    }
+}

package/lib/dist/features/color.d.ts

@@ -0,0 +1,11 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+export declare class Color extends SceneObject {
+    private color;
+    private _selection;
+    constructor(color: string, selection?: SceneObject);
+    get selection(): SceneObject;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: Color): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/color.js

@@ -0,0 +1,93 @@
+import { SceneObject } from "../common/scene-object.js";
+import { SelectSceneObject } from "./select.js";
+import cssColorNames from "color-name";
+function toHex(color) {
+    if (color.startsWith('#')) {
+        return color;
+    }
+    const rgb = cssColorNames[color.toLowerCase()];
+    if (rgb) {
+        return '#' + rgb.map(c => c.toString(16).padStart(2, '0')).join('');
+    }
+    return color;
+}
+export class Color extends SceneObject {
+    color;
+    _selection = null;
+    constructor(color, selection) {
+        super();
+        this.color = color;
+        this.color = toHex(color);
+        this._selection = selection ?? null;
+    }
+    get selection() {
+        return this._selection;
+    }
+    build(context) {
+        const sceneObjects = context.getSceneObjects();
+        const objShapeMap = new Map();
+        for (const obj of sceneObjects) {
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            for (const shape of shapes) {
+                objShapeMap.set(shape, obj);
+            }
+        }
+        const allShapes = Array.from(objShapeMap.keys());
+        const targetFaces = this.selection.getShapes();
+        console.log('Color: Target faces from selection:', targetFaces.length);
+        // Group faces by their owner solid
+        const facesByOwner = new Map();
+        for (const face of targetFaces) {
+            const ownerShape = allShapes.find(s => s.hasFace(face.getShape()));
+            if (ownerShape) {
+                let faces = facesByOwner.get(ownerShape);
+                if (!faces) {
+                    faces = [];
+                    facesByOwner.set(ownerShape, faces);
+                }
+                faces.push(face);
+            }
+            else {
+                console.log('Color: Could not find owner shape for face, skipping. Face:', face);
+            }
+        }
+        // Apply all face colors per solid in a single copy
+        for (const [ownerShape, faces] of facesByOwner) {
+            const newSolid = ownerShape.copy();
+            for (const face of faces) {
+                newSolid.setColor(face.getShape(), this.color);
+            }
+            if (this.selection instanceof SelectSceneObject) {
+                for (const face of faces) {
+                    this.selection.removeShape(face, this);
+                }
+            }
+            const ownerObj = objShapeMap.get(ownerShape);
+            if (ownerObj) {
+                ownerObj.removeShape(ownerShape, this);
+            }
+            this.addShape(newSolid);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof Color)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.color !== other.color) {
+            return false;
+        }
+        if (!this.selection.compareTo(other.selection)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return 'color';
+    }
+    serialize() {
+        return {};
+    }
+}

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

@@ -0,0 +1,12 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+export declare class Common extends SceneObject {
+    private _sceneObjects;
+    private _keepOriginal;
+    constructor(...objects: SceneObject[]);
+    keepOriginal(value?: boolean): this;
+    get sceneObjects(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: Common): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/common.js

@@ -0,0 +1,70 @@
+import { SceneObject } from "../common/scene-object.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+export class Common extends SceneObject {
+    _sceneObjects = [];
+    _keepOriginal = false;
+    constructor(...objects) {
+        super();
+        this._sceneObjects = objects;
+    }
+    keepOriginal(value = true) {
+        this._keepOriginal = value;
+        return this;
+    }
+    get sceneObjects() {
+        return this._sceneObjects;
+    }
+    build(context) {
+        let sceneObjects = this.sceneObjects;
+        if (sceneObjects?.length === 0) {
+            sceneObjects = context.getSceneObjects();
+        }
+        const objShapeMap = new Map();
+        for (const obj of sceneObjects) {
+            for (const shape of obj.getShapes({ excludeMeta: false }, 'solid')) {
+                objShapeMap.set(shape, obj);
+            }
+        }
+        const allShapes = Array.from(objShapeMap.keys());
+        if (allShapes.length < 2) {
+            return;
+        }
+        const { newShapes, modifiedShapes, result } = BooleanOps.common(allShapes);
+        if (!modifiedShapes.length && newShapes.length === 0) {
+            return;
+        }
+        if (!this._keepOriginal) {
+            for (const shape of allShapes) {
+                const obj = objShapeMap.get(shape);
+                obj.removeShape(shape, this);
+            }
+        }
+        this.addShapes(newShapes.length > 0 ? newShapes : result);
+    }
+    compareTo(other) {
+        if (!(other instanceof Common)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._keepOriginal !== other._keepOriginal) {
+            return false;
+        }
+        if (this.sceneObjects.length !== other.sceneObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this.sceneObjects.length; i++) {
+            if (!this.sceneObjects[i].compareTo(other.sceneObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "common";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/common2d.d.ts

@@ -0,0 +1,15 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Common2D extends GeometrySceneObject {
+    private _targetObjects;
+    private _keepOriginal;
+    constructor(...targets: GeometrySceneObject[]);
+    keepOriginal(value?: boolean): this;
+    get targetObjects(): GeometrySceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Common2D): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/common2d.js

@@ -0,0 +1,96 @@
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { WireOps } from "../oc/wire-ops.js";
+export class Common2D extends GeometrySceneObject {
+    _targetObjects = null;
+    _keepOriginal = false;
+    constructor(...targets) {
+        super();
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    keepOriginal(value = true) {
+        this._keepOriginal = value;
+        return this;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let sourceEdges;
+        if (this._targetObjects === null) {
+            sourceEdges = this.sketch.getGeometriesWithOwner();
+        }
+        else {
+            sourceEdges = new Map();
+            for (const obj of this._targetObjects) {
+                for (const shape of obj.getShapes()) {
+                    if (shape instanceof Edge) {
+                        sourceEdges.set(shape, obj);
+                    }
+                    else if (shape instanceof Wire) {
+                        for (const edge of shape.getEdges()) {
+                            sourceEdges.set(edge, obj);
+                        }
+                    }
+                }
+            }
+        }
+        const allEdges = Array.from(sourceEdges.keys()).filter(edge => edge.isClosed());
+        const wires = allEdges.map(edge => WireOps.makeWireFromEdges([edge]));
+        const faces = wires.map(wire => FaceOps.makeFaceWrapped(wire));
+        const { newShapes } = BooleanOps.common(faces);
+        if (newShapes.length === 0) {
+            return;
+        }
+        const newEdges = newShapes.flatMap((face) => face.getEdges());
+        if (!this._keepOriginal) {
+            for (const [wire, owner] of sourceEdges) {
+                if (!allEdges.includes(wire)) {
+                    continue;
+                }
+                owner.removeShape(wire, this);
+            }
+        }
+        this.addShapes(newEdges);
+    }
+    getDependencies() {
+        return this._targetObjects ? [...this._targetObjects] : [];
+    }
+    createCopy(remap) {
+        const targets = this._targetObjects
+            ? this._targetObjects.map(t => remap.get(t) || t)
+            : [];
+        return new Common2D(...targets);
+    }
+    compareTo(other) {
+        if (!(other instanceof Common2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._keepOriginal !== other._keepOriginal) {
+            return false;
+        }
+        const thisTargets = this._targetObjects || [];
+        const otherTargets = other._targetObjects || [];
+        if (thisTargets.length !== otherTargets.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargets.length; i++) {
+            if (!thisTargets[i].compareTo(otherTargets[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "common2d";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/copy-circular.d.ts

@@ -0,0 +1,23 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Axis } from "../math/axis.js";
+export type CircularCopyOptions = {
+    count: number;
+    centered?: boolean;
+    skip?: number[];
+} & ({
+    offset: number;
+    angle?: never;
+} | {
+    angle: number;
+    offset?: never;
+});
+export declare class CopyCircular extends SceneObject {
+    axis: Axis;
+    options: CircularCopyOptions;
+    targetObjects: SceneObject[] | null;
+    constructor(axis: Axis, options: CircularCopyOptions, targetObjects?: SceneObject[] | null);
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: CopyCircular): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/copy-circular.js

@@ -0,0 +1,73 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class CopyCircular extends SceneObject {
+    axis;
+    options;
+    targetObjects;
+    constructor(axis, options, targetObjects = null) {
+        super();
+        this.axis = axis;
+        this.options = options;
+        this.targetObjects = targetObjects;
+    }
+    build(context) {
+        let objects = this.targetObjects;
+        if (!this.targetObjects) {
+            objects = context.getActiveSceneObjects();
+        }
+        const { count, centered, skip } = this.options;
+        let offset;
+        if ('offset' in this.options && this.options.offset !== undefined) {
+            offset = this.options.offset;
+        }
+        else {
+            offset = this.options.angle / count;
+        }
+        const startOffset = centered ? -(count * offset) / 2 : 0;
+        for (let i = 1; i < count; i++) {
+            if (skip?.includes(i))
+                continue;
+            const angle = startOffset + offset * i;
+            const matrix = Matrix4.fromRotationAroundAxis(this.axis.origin, this.axis.direction, rad(angle));
+            for (const obj of objects) {
+                for (const shape of obj.getShapes()) {
+                    const transformed = ShapeOps.transform(shape, matrix);
+                    this.addShape(transformed);
+                }
+            }
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof CopyCircular)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.axis.equals(other.axis)) {
+            return false;
+        }
+        const thisTargetObjects = this.targetObjects || [];
+        const otherTargetObjects = other.targetObjects || [];
+        if (thisTargetObjects.length !== otherTargetObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargetObjects.length; i++) {
+            if (!thisTargetObjects[i].compareTo(otherTargetObjects[i])) {
+                return false;
+            }
+        }
+        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "copy-circular";
+    }
+    serialize() {
+        return {};
+    }
+}