fluidcad 0.0.2

package/lib/dist/features/region2d.js

@@ -0,0 +1,185 @@
+import { SceneObject } from "../common/scene-object.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+export class Region2D extends SceneObject {
+    _points = [];
+    _extrudable;
+    constructor(extrudable) {
+        super();
+        this._extrudable = extrudable;
+    }
+    points(...ps) {
+        this._points = ps;
+        return this;
+    }
+    isExtrudable() {
+        return true;
+    }
+    build() {
+        const plane = this._extrudable.getPlane();
+        const shapes = this._extrudable.getGeometries();
+        const allFaces = FaceOps.buildPlanarFaces(shapes, plane);
+        if (allFaces.length === 0) {
+            return;
+        }
+        // Compute bounding box diagonals for disambiguation (smallest face wins)
+        const faceDiagonals = allFaces.map(face => {
+            const bbox = ShapeOps.getBoundingBox(face);
+            return Math.sqrt((bbox.maxX - bbox.minX) ** 2 +
+                (bbox.maxY - bbox.minY) ** 2);
+        });
+        // Match each user point to the smallest face containing it
+        const selectedIndices = new Set();
+        const pointForFace = new Map();
+        for (const lazyPoint of this._points) {
+            const point2d = lazyPoint.asPoint2D();
+            const point3d = plane.localToWorld(point2d);
+            let bestIdx = -1;
+            let bestDiag = Infinity;
+            for (let i = 0; i < allFaces.length; i++) {
+                if (FaceOps.isPointInsideFace(point3d, allFaces[i])) {
+                    if (faceDiagonals[i] < bestDiag) {
+                        bestDiag = faceDiagonals[i];
+                        bestIdx = i;
+                    }
+                }
+            }
+            if (bestIdx >= 0) {
+                selectedIndices.add(bestIdx);
+                // Store rounded values to match what handleInsertPoint writes to source code
+                pointForFace.set(bestIdx, [
+                    Math.round(point2d.x * 100) / 100,
+                    Math.round(point2d.y * 100) / 100,
+                ]);
+            }
+        }
+        // Determine nesting: find holes for each selected face
+        const holesFor = new Map();
+        for (const selIdx of selectedIndices) {
+            const holes = [];
+            for (let i = 0; i < allFaces.length; i++) {
+                if (i === selIdx || selectedIndices.has(i)) {
+                    continue;
+                }
+                const innerWires = Explorer.findWiresWrapped(allFaces[i]);
+                if (innerWires.length > 0) {
+                    const firstVertex = innerWires[0].getFirstVertex();
+                    if (firstVertex && FaceOps.isPointInsideFace(firstVertex.toPoint(), allFaces[selIdx])) {
+                        holes.push(i);
+                    }
+                }
+            }
+            if (holes.length > 0) {
+                holesFor.set(selIdx, holes);
+            }
+        }
+        // Extract wires for getGeometries() BEFORE drilling (which mutates wires in-place)
+        const resultWires = [];
+        for (const selIdx of selectedIndices) {
+            const wires = Explorer.findWiresWrapped(allFaces[selIdx]);
+            if (wires.length > 0) {
+                resultWires.push(wires[0]);
+            }
+        }
+        for (const [, holeIndices] of holesFor) {
+            for (const hi of holeIndices) {
+                const wires = Explorer.findWiresWrapped(allFaces[hi]);
+                if (wires.length > 0) {
+                    resultWires.push(wires[0]);
+                }
+            }
+        }
+        this.setState('result-wires', resultWires);
+        // Build drilled faces for selected regions with holes
+        const drilledFaces = new Map();
+        for (const [selIdx, holeIndices] of holesFor) {
+            const outerWires = Explorer.findWiresWrapped(allFaces[selIdx]);
+            if (outerWires.length === 0) {
+                continue;
+            }
+            const outerWire = outerWires[0];
+            const holeWires = [];
+            for (const hi of holeIndices) {
+                const wires = Explorer.findWiresWrapped(allFaces[hi]);
+                if (wires.length > 0) {
+                    wires[0].getShape().Reverse();
+                    holeWires.push(wires[0]);
+                }
+            }
+            if (holeWires.length > 0) {
+                drilledFaces.set(selIdx, FaceOps.makeFaceWithHoles(outerWire, holeWires));
+            }
+        }
+        // Add ALL faces as shapes (for rendering/raycasting)
+        // Selected faces that have holes are replaced with drilled versions
+        for (let i = 0; i < allFaces.length; i++) {
+            const face = drilledFaces.has(i) ? drilledFaces.get(i) : allFaces[i];
+            this.addShape(face);
+        }
+        // Build selection mapping: map shape indices to their selection state
+        const addedShapes = this.getOwnShapes({ excludeMeta: false, excludeGuide: false });
+        const selections = [];
+        for (let i = 0; i < addedShapes.length; i++) {
+            if (selectedIndices.has(i) && pointForFace.has(i)) {
+                selections.push({
+                    shapeId: addedShapes[i].id,
+                    point: pointForFace.get(i),
+                });
+            }
+        }
+        this.setState('selections', selections);
+        this.setState('all-face-count', allFaces.length);
+        this.setState('selected-indices', [...selectedIndices]);
+    }
+    getGeometries() {
+        return this.getState('result-wires') || [];
+    }
+    getGeometriesWithOwner() {
+        const result = new Map();
+        for (const wire of this.getGeometries()) {
+            result.set(wire, this);
+        }
+        return result;
+    }
+    getPlane() {
+        return this._extrudable.getPlane();
+    }
+    getDependencies() {
+        return [this._extrudable];
+    }
+    createCopy(remap) {
+        const extrudable = (remap.get(this._extrudable) || this._extrudable);
+        const copy = new Region2D(extrudable);
+        if (this._points.length > 0) {
+            copy.points(...this._points);
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Region2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._points.length !== other._points.length) {
+            return false;
+        }
+        for (let i = 0; i < this._points.length; i++) {
+            if (!this._points[i].compareTo(other._points[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "region";
+    }
+    serialize() {
+        return {
+            plane: this._extrudable.serialize?.()?.plane || null,
+            selections: this.getState('selections') || [],
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+import { SceneObject } from "../common/scene-object.js";
+export declare class Remove extends SceneObject {
+    objects: SceneObject[];
+    constructor(objects: SceneObject[]);
+    build(): void;
+    compareTo(other: Remove): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/remove.js

@@ -0,0 +1,33 @@
+import { SceneObject } from "../common/scene-object.js";
+export class Remove extends SceneObject {
+    objects;
+    constructor(objects) {
+        super();
+        this.objects = objects;
+    }
+    build() {
+        for (const obj of this.objects) {
+            obj.removeShapes(this);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof Remove)) {
+            return false;
+        }
+        if (this.objects.length !== other.objects.length) {
+            return false;
+        }
+        for (let i = 0; i < this.objects.length; i++) {
+            if (!this.objects[i].compareTo(other.objects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return 'remove';
+    }
+    serialize() {
+        return {};
+    }
+}

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

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

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

@@ -0,0 +1,47 @@
+import { SceneObject } from "../common/scene-object.js";
+export class RepeatCircular extends SceneObject {
+    axis;
+    options;
+    targetObjects;
+    constructor(axis, options, targetObjects = null) {
+        super();
+        this.axis = axis;
+        this.options = options;
+        this.targetObjects = targetObjects;
+        this.setAlwaysVisible();
+    }
+    build(context) {
+        this.saveShapesSnapshot(context);
+    }
+    compareTo(other) {
+        if (!(other instanceof RepeatCircular)) {
+            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 "repeat-circular";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/repeat-circular2d.d.ts

@@ -0,0 +1,17 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { LazyVertex } from "./lazy-vertex.js";
+import { CircularRepeatOptions } from "./repeat-circular.js";
+export declare class RepeatCircular2D extends GeometrySceneObject {
+    center: LazyVertex;
+    options: CircularRepeatOptions;
+    private _targetObjects;
+    constructor(center: LazyVertex, options: CircularRepeatOptions);
+    target(...objects: SceneObject[]): this;
+    get targetObjects(): SceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: RepeatCircular2D): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}

package/lib/dist/features/repeat-circular2d.js

@@ -0,0 +1,90 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export class RepeatCircular2D extends GeometrySceneObject {
+    center;
+    options;
+    _targetObjects = null;
+    constructor(center, options) {
+        super();
+        this.center = center;
+        this.options = options;
+    }
+    target(...objects) {
+        this._targetObjects = objects;
+        return this;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let objects;
+        const allSiblings = this.sketch.getPreviousSiblings(this);
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            objects = allSiblings.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            objects = allSiblings;
+        }
+        const plane = this.sketch.getPlane();
+        const origin = plane.localToWorld(this.center.asPoint2D());
+        const direction = plane.normal;
+        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 - 1);
+        }
+        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(origin, direction, rad(angle));
+            for (const obj of objects) {
+                for (const shape of obj.getShapes()) {
+                    const transformed = ShapeOps.transform(shape, matrix);
+                    this.addShape(transformed);
+                }
+            }
+        }
+        this.setCurrentPosition(this.center.asPoint2D());
+    }
+    compareTo(other) {
+        if (!(other instanceof RepeatCircular2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.center.compareTo(other.center)) {
+            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 "repeat-circular";
+    }
+    getUniqueType() {
+        return "repeat-circular-2d";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/repeat-linear.d.ts

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

package/lib/dist/features/repeat-linear.js

@@ -0,0 +1,52 @@
+import { SceneObject } from "../common/scene-object.js";
+export class RepeatLinear extends SceneObject {
+    axes;
+    options;
+    targetObjects;
+    constructor(axes, options, targetObjects = null) {
+        super();
+        this.axes = axes;
+        this.options = options;
+        this.targetObjects = targetObjects;
+        this.setAlwaysVisible();
+    }
+    build(context) {
+        this.saveShapesSnapshot(context);
+    }
+    compareTo(other) {
+        if (!(other instanceof RepeatLinear)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.axes.length !== other.axes.length) {
+            return false;
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            if (!this.axes[i].equals(other.axes[i])) {
+                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 "repeat-linear";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/repeat-linear2d.d.ts

@@ -0,0 +1,17 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Axis } from "../math/axis.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { LinearRepeatOptions } from "./repeat-linear.js";
+export declare class RepeatLinear2D extends GeometrySceneObject {
+    axes: Axis[];
+    options: LinearRepeatOptions;
+    private _targetObjects;
+    constructor(axes: Axis[], options: LinearRepeatOptions);
+    target(...objects: SceneObject[]): this;
+    get targetObjects(): SceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: RepeatLinear2D): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {};
+}

package/lib/dist/features/repeat-linear2d.js

@@ -0,0 +1,114 @@
+import { Matrix4 } from "../math/matrix4.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export class RepeatLinear2D extends GeometrySceneObject {
+    axes;
+    options;
+    _targetObjects = null;
+    constructor(axes, options) {
+        super();
+        this.axes = axes;
+        this.options = options;
+    }
+    target(...objects) {
+        this._targetObjects = objects;
+        return this;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let objects;
+        const allSiblings = this.sketch.getPreviousSiblings(this);
+        if (this.targetObjects && this.targetObjects.length > 0) {
+            objects = allSiblings.filter(obj => this.targetObjects.includes(obj));
+        }
+        else {
+            objects = allSiblings;
+        }
+        const counts = Array.isArray(this.options.count)
+            ? this.options.count
+            : [this.options.count];
+        const axisOffsets = this.axes.map((axis, i) => {
+            const count = counts[i] ?? counts[0];
+            const offset = this.options.offset != null
+                ? this.options.offset
+                : this.options.length / (count - 1);
+            return { axis, count, offset };
+        });
+        // Generate all index combinations across axes
+        let positions = [[]];
+        for (const { count } of axisOffsets) {
+            const next = [];
+            for (const pos of positions) {
+                for (let i = 0; i < count; i++) {
+                    next.push([...pos, i]);
+                }
+            }
+            positions = next;
+        }
+        for (const pos of positions) {
+            if (pos.every(idx => idx === 0))
+                continue;
+            if (this.options.skip?.some(s => s.length === pos.length && s.every((v, i) => v === pos[i]))) {
+                continue;
+            }
+            let dx = 0, dy = 0, dz = 0;
+            for (let a = 0; a < axisOffsets.length; a++) {
+                const { axis, offset } = axisOffsets[a];
+                const idx = this.options.centered
+                    ? pos[a] - Math.floor(axisOffsets[a].count / 2)
+                    : pos[a];
+                dx += axis.direction.x * offset * idx;
+                dy += axis.direction.y * offset * idx;
+                dz += axis.direction.z * offset * idx;
+            }
+            const matrix = Matrix4.fromTranslation(dx, dy, dz);
+            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 RepeatLinear2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.axes.length !== other.axes.length) {
+            return false;
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            if (!this.axes[i].equals(other.axes[i])) {
+                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 "repeat-linear";
+    }
+    getUniqueType() {
+        return "repeat-linear-2d";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/revolve-options.d.ts

@@ -0,0 +1,6 @@
+import { SceneObject } from "../common/scene-object.js";
+export type MergeScope = 'all' | 'none' | SceneObject | SceneObject[];
+export type RevolveOptions = {
+    mergeScope?: MergeScope;
+    symmetric?: boolean;
+};

package/lib/dist/features/revolve-options.js

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

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

@@ -0,0 +1,23 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { IRevolve } from "../core/interfaces.js";
+export declare class Revolve extends ExtrudeBase implements IRevolve {
+    axis: AxisObjectBase;
+    angle: number;
+    constructor(axis: AxisObjectBase, angle: number, extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Revolve): boolean;
+    getType(): string;
+    serialize(): {
+        angle: number;
+        axis: any;
+        operationMode: "new" | "remove";
+        symmetric: true;
+        picking: true;
+        pickPoints: number[][];
+    };
+}