fluidcad 0.0.2

package/lib/dist/features/extrude-symmetric.js

@@ -0,0 +1,177 @@
+import { rad } from "../helpers/math-helpers.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
+import { FaceMaker } from "../core/2d/face-maker.js";
+import { ExtrudeOps } from "../oc/extrude-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { LazySceneObject } from "./lazy-scene-object.js";
+export class ExtrudeSymmetric extends ExtrudeBase {
+    extrudable;
+    distance;
+    options;
+    constructor(extrudable, distance, options = {}) {
+        super(options);
+        this.extrudable = extrudable;
+        this.distance = distance;
+        this.options = options;
+    }
+    build(context) {
+        let solids = [];
+        const sceneObjects = context.getSceneObjects();
+        const wires = this.extrudable.getGeometries();
+        const faces = FaceMaker.getFaces(wires, this.extrudable.getPlane());
+        console.log("Extruding faces:", faces);
+        const plane = this.extrudable.getPlane();
+        const hasDraft = !!this.options?.draft;
+        let startFaces = [];
+        let endFaces = [];
+        let sideFaces = [];
+        if (hasDraft) {
+            let vec = plane.normal.multiply(this.distance / 2);
+            for (const face of faces) {
+                let { solid, firstFace, lastFace } = this.doExtrude(face, vec);
+                solid = this.applyDraft(solid, firstFace, lastFace, plane);
+                const center = face.center();
+                const mirrored = ShapeOps.mirrorShape(solid, center);
+                const fused = BooleanOps.fuseShapes(solid, mirrored);
+                const solidFaces = Explorer.findFacesWrapped(fused);
+                for (const f of solidFaces) {
+                    if (f.getShape().IsSame(firstFace.getShape())) {
+                        startFaces.push(f);
+                    }
+                    else if (f.getShape().IsSame(lastFace.getShape())) {
+                        endFaces.push(f);
+                    }
+                    else {
+                        sideFaces.push(f);
+                    }
+                }
+                solids.push(fused);
+            }
+        }
+        else {
+            let vec = plane.normal.multiply(this.distance);
+            const translateVec = vec.multiply(-0.5);
+            for (const face of faces) {
+                let { solid, firstFace, lastFace } = this.doExtrude(face, vec);
+                solid = ShapeOps.translateShape(solid, translateVec);
+                const solidFaces = Explorer.findFacesWrapped(solid);
+                for (const f of solidFaces) {
+                    // here we use IsPartner instead of IsSame because the place location has changed after translation
+                    if (f.getShape().IsPartner(firstFace.getShape())) {
+                        startFaces.push(f);
+                    }
+                    else if (f.getShape().IsPartner(lastFace.getShape())) {
+                        endFaces.push(f);
+                    }
+                    else {
+                        sideFaces.push(f);
+                    }
+                }
+                solids.push(solid);
+            }
+        }
+        this.setState('start-faces', startFaces);
+        this.setState('end-faces', endFaces);
+        this.setState('side-faces', sideFaces);
+        this.extrudable.removeShapes(this);
+        if (this.options?.mergeScope === 'none' || solids.length === 0 || sceneObjects?.length === 0) {
+            const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+            solids = fusionResult.extrusions;
+            for (const modifiedShape of fusionResult.modifiedShapes) {
+                modifiedShape.object.removeShape(modifiedShape.shape, this);
+            }
+        }
+        this.addShapes(solids);
+    }
+    applyDraft(solid, firstFace, lastFace, plane) {
+        if (this.options.draft instanceof Array) {
+            throw new Error("Draft with two angles for start and end faces is supported only for extrusions with two distances");
+        }
+        const angle = this.options.draft;
+        return ExtrudeOps.applyDraftOnSideFaces(solid, firstFace, lastFace, plane, rad(angle));
+    }
+    doExtrude(shape, vector) {
+        const { solid: rawSolid, firstFace, lastFace } = ExtrudeOps.makePrismFromVec(shape, vector);
+        const solid = ShapeOps.cleanShape(rawSolid);
+        return { solid, firstFace, lastFace };
+    }
+    getUniqueName(suffix) {
+        return `${this.getOrder()}-${this.getUniqueType()}-${suffix}`;
+    }
+    startFace(...indices) {
+        const suffix = indices.length > 0 ? `start-faces-${indices.join('-')}` : 'start-faces';
+        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
+            const faces = this.getState('start-faces') || [];
+            if (indices.length === 0)
+                return faces.length > 0 ? [faces[0]] : [];
+            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
+        });
+    }
+    endFace(...indices) {
+        const suffix = indices.length > 0 ? `end-faces-${indices.join('-')}` : 'end-faces';
+        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
+            const faces = this.getState('end-faces') || [];
+            if (indices.length === 0)
+                return faces.length > 0 ? [faces[0]] : [];
+            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
+        });
+    }
+    startEdge(...indices) {
+        const suffix = indices.length > 0 ? `start-edges-${indices.join('-')}` : 'start-edges';
+        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
+            const faces = this.getState('start-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            if (indices.length === 0)
+                return edges.length > 0 ? [edges[0]] : [];
+            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
+        });
+    }
+    endEdge(...indices) {
+        const suffix = indices.length > 0 ? `end-edges-${indices.join('-')}` : 'end-edges';
+        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
+            const faces = this.getState('end-faces') || [];
+            const edges = faces.flatMap(f => f.getEdges());
+            if (indices.length === 0)
+                return edges.length > 0 ? [edges[0]] : [];
+            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
+        });
+    }
+    sideFace(...indices) {
+        const suffix = indices.length > 0 ? `side-faces-${indices.join('-')}` : 'side-faces';
+        return new LazySceneObject(`${this.getUniqueName(suffix)}`, () => {
+            const faces = this.getState('side-faces') || [];
+            if (indices.length === 0)
+                return faces.length > 0 ? [faces[0]] : [];
+            return indices.filter(i => i >= 0 && i < faces.length).map(i => faces[i]);
+        });
+    }
+    compareTo(other) {
+        if (!(other instanceof ExtrudeSymmetric)) {
+            return false;
+        }
+        if (this.distance !== other.distance) {
+            return false;
+        }
+        if (JSON.stringify(this.options || {}) !== JSON.stringify(other.options || {})) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'extrude-symmetric';
+    }
+    serialize() {
+        return {
+            extrudables: this.extrudable.serialize(),
+            distance: this.distance,
+            symmetric: true,
+            options: this.options
+        };
+    }
+}

package/lib/dist/features/extrude-to-face.d.ts

@@ -0,0 +1,35 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { Extrudable } from "../helpers/types.js";
+export declare class ExtrudeToFace extends ExtrudeBase {
+    face: SceneObject | 'first-face' | 'last-face';
+    constructor(face: SceneObject | 'first-face' | 'last-face', extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    private createAdvancedExtrude;
+    private resizePlanarFace;
+    private resizeCylindricalFace;
+    /**
+     * Computes the signed distance from the sketch plane to the farthest
+     * bounding-box corner of the target face, measured along the sketch
+     * plane normal. This ensures the extrusion direction is always
+     * consistent with the sketch plane orientation.
+     */
+    private computeSignedDistanceToFace;
+    private splitShapesByFace;
+    private createSimpleExtrude;
+    private getFace;
+    private getFirstOrLastFace;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: ExtrudeToFace): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        sheptType: string;
+        extrudable: any;
+        draft: [number, number];
+        endOffset: number;
+        face: string;
+        picking: true;
+        pickPoints: number[][];
+    };
+}

package/lib/dist/features/extrude-to-face.js

@@ -0,0 +1,275 @@
+import { SceneObject } from "../common/scene-object.js";
+import { Face } from "../common/shapes.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { Extruder } from "./simple-extruder.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { FaceQuery } from "../oc/face-query.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { Point } from "../math/point.js";
+export class ExtrudeToFace extends ExtrudeBase {
+    face;
+    constructor(face, extrudable) {
+        super(extrudable);
+        this.face = face;
+    }
+    build(context) {
+        const allSceneObjects = context.getSceneObjects();
+        const sceneObjects = this.resolveFusionScope(allSceneObjects);
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        const targetFace = this.getFace(allSceneObjects);
+        const isPlanar = FaceQuery.isPlanarFace(targetFace);
+        let solids = [];
+        const allStartFaces = [];
+        const allEndFaces = [];
+        const allSideFaces = [];
+        const allInternalFaces = [];
+        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        for (const startFace of faces) {
+            if (isPlanar && FaceQuery.areFacePlanesParallel(startFace, targetFace)) {
+                const { shapes, extruder } = this.createSimpleExtrude(startFace, targetFace, plane);
+                for (const s of shapes) {
+                    solids.push(s);
+                }
+                allStartFaces.push(...extruder.getStartFaces());
+                allEndFaces.push(...extruder.getEndFaces());
+                allSideFaces.push(...extruder.getSideFaces());
+                allInternalFaces.push(...extruder.getInternalFaces());
+            }
+            else {
+                console.log("Creating advanced extrude for face:");
+                const advancedShapes = this.createAdvancedExtrude(startFace, targetFace, isPlanar, plane);
+                for (const shape of advancedShapes) {
+                    solids.push(shape);
+                }
+            }
+        }
+        this.setState('start-faces', allStartFaces);
+        this.setState('end-faces', allEndFaces);
+        this.setState('side-faces', allSideFaces);
+        this.setState('internal-faces', allInternalFaces);
+        this.extrudable.removeShapes(this);
+        if (this.face instanceof SceneObject) {
+            this.face.removeShapes(this);
+        }
+        if (this._operationMode === 'remove') {
+            const scope = this.resolveFusionScope(allSceneObjects);
+            cutWithSceneObjects(scope, solids, plane, 0, this);
+            return;
+        }
+        if (sceneObjects.length === 0) {
+            this.addShapes(solids);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (modifiedShape.object) {
+                modifiedShape.object.removeShape(modifiedShape.shape, this);
+            }
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    createAdvancedExtrude(sourceFace, targetFace, isPlanar, sketchPlane) {
+        const targetDistance = this.computeSignedDistanceToFace(targetFace, sketchPlane);
+        let distance = targetDistance;
+        if (isPlanar) {
+            distance *= 1.5;
+        }
+        const extruder = new Extruder([sourceFace], sketchPlane, distance, this.getDraft(), 0);
+        const extrusions = extruder.extrude();
+        let splitTargetFace;
+        if (isPlanar) {
+            console.log("Resizing planar target face for splitting");
+            splitTargetFace = this.resizePlanarFace(targetFace);
+        }
+        else {
+            const surfaceType = FaceQuery.getSurfaceType(targetFace);
+            if (surfaceType === 'cylinder') {
+                splitTargetFace = this.resizeCylindricalFace(targetFace);
+            }
+            else {
+                splitTargetFace = targetFace;
+            }
+        }
+        const splitShapes = this.splitShapesByFace(extrusions, splitTargetFace);
+        return splitShapes;
+    }
+    resizePlanarFace(targetFace) {
+        const endOffset = this.getEndOffset();
+        if (endOffset) {
+            const dir = this.extrudable.getPlane().normal.reverse();
+            return FaceQuery.makeInfinitePlanarFace(targetFace, endOffset, dir);
+        }
+        return FaceQuery.makeInfinitePlanarFace(targetFace);
+    }
+    resizeCylindricalFace(targetFace) {
+        return FaceQuery.makeInfiniteCylindricalFace(targetFace, this.getEndOffset());
+    }
+    /**
+     * Computes the signed distance from the sketch plane to the farthest
+     * bounding-box corner of the target face, measured along the sketch
+     * plane normal. This ensures the extrusion direction is always
+     * consistent with the sketch plane orientation.
+     */
+    computeSignedDistanceToFace(targetFace, sketchPlane) {
+        const bbox = ShapeOps.getBoundingBox(targetFace);
+        const corners = [
+            new Point(bbox.minX, bbox.minY, bbox.minZ),
+            new Point(bbox.maxX, bbox.minY, bbox.minZ),
+            new Point(bbox.minX, bbox.maxY, bbox.minZ),
+            new Point(bbox.minX, bbox.minY, bbox.maxZ),
+            new Point(bbox.maxX, bbox.maxY, bbox.minZ),
+            new Point(bbox.maxX, bbox.minY, bbox.maxZ),
+            new Point(bbox.minX, bbox.maxY, bbox.maxZ),
+            new Point(bbox.maxX, bbox.maxY, bbox.maxZ),
+        ];
+        let maxDistance = 0;
+        for (const corner of corners) {
+            const d = sketchPlane.signedDistanceToPoint(corner);
+            if (Math.abs(d) > Math.abs(maxDistance)) {
+                maxDistance = d;
+            }
+        }
+        return maxDistance;
+    }
+    splitShapesByFace(extrusions, targetFace) {
+        const result = [];
+        const sourcePlane = this.extrudable.getPlane();
+        for (const shape of extrusions) {
+            const solids = BooleanOps.splitShape(shape, targetFace);
+            if (solids.length === 1) {
+                result.push(ShapeOps.cleanShape(solids[0]));
+            }
+            else {
+                let keep = null;
+                for (const s of solids) {
+                    const faces = Explorer.findFacesWrapped(s);
+                    if (faces.some(f => FaceOps.faceOnPlaneWrapped(f, sourcePlane))) {
+                        keep = s;
+                        break;
+                    }
+                }
+                if (!keep) {
+                    throw new Error("Could not find modified shape with source face");
+                }
+                result.push(ShapeOps.cleanShape(keep));
+            }
+        }
+        return result;
+    }
+    createSimpleExtrude(startFace, targetFace, sketchPlane) {
+        const targetPlane = FaceQuery.getSurfacePlane(targetFace);
+        const distance = sketchPlane.signedDistanceToPoint(targetPlane.origin);
+        const extruder = new Extruder([startFace], sketchPlane, distance, this.getDraft(), this.getEndOffset());
+        const shapes = extruder.extrude();
+        return { shapes, extruder };
+    }
+    getFace(sceneObjects) {
+        if (this.face instanceof SceneObject) {
+            const selection = this.face.getShapes();
+            if (selection.length === 0) {
+                throw new Error("Selection is empty");
+            }
+            else if (selection.length > 1) {
+                throw new Error("Selection has more than one shape");
+            }
+            const shape = selection[0];
+            if (!(shape instanceof Face)) {
+                throw new Error("Selection is not a face");
+            }
+            return shape;
+        }
+        else if (this.face === 'first-face') {
+            return this.getFirstOrLastFace(sceneObjects, 'first');
+        }
+        else if (this.face === 'last-face') {
+            return this.getFirstOrLastFace(sceneObjects, 'last');
+        }
+        else {
+            throw new Error("Invalid face parameter");
+        }
+    }
+    getFirstOrLastFace(sceneObjects, mode) {
+        const plane = this.extrudable.getPlane();
+        const allFaces = [];
+        for (const obj of sceneObjects) {
+            if (obj === this.extrudable) {
+                continue;
+            }
+            for (const shape of obj.getShapes()) {
+                const faces = Explorer.findFacesWrapped(shape);
+                for (const face of faces) {
+                    allFaces.push(face);
+                }
+            }
+        }
+        const result = FaceQuery.findFaceByDistance(allFaces, plane, mode);
+        if (!result) {
+            throw new Error(`No face found for '${mode}-face' extrusion`);
+        }
+        return result;
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.extrudable) {
+            deps.push(this.extrudable);
+        }
+        if (this.face instanceof SceneObject) {
+            deps.push(this.face);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const newFace = this.face instanceof SceneObject
+            ? (remap.get(this.face) || this.face)
+            : this.face;
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new ExtrudeToFace(newFace, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof ExtrudeToFace)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        if (typeof (this.face) !== typeof (other.face)) {
+            return false;
+        }
+        if (this.face instanceof SceneObject && other.face instanceof SceneObject && !this.face.compareTo(other.face)) {
+            return false;
+        }
+        if (this.face !== other.face) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'extrude-to-face';
+    }
+    serialize() {
+        return {
+            sheptType: 'wire',
+            extrudable: this.extrudable.serialize(),
+            draft: this.getDraft(),
+            endOffset: this.getEndOffset(),
+            face: typeof (this.face) === 'string' ? this.face : 'selection',
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
+    }
+}

package/lib/dist/features/extrude-two-distances.d.ts

@@ -0,0 +1,21 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { Extrudable } from "../helpers/types.js";
+export declare class ExtrudeTwoDistances extends ExtrudeBase {
+    distance1: number;
+    distance2: number;
+    constructor(distance1: number, distance2: number, extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: ExtrudeTwoDistances): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        extrudable: any;
+        distance1: number;
+        distance2: number;
+        operationMode: "new" | "remove";
+        picking: true;
+        pickPoints: number[][];
+    };
+}

package/lib/dist/features/extrude-two-distances.js

@@ -0,0 +1,116 @@
+import { ExtrudeBase } from "./extrude-base.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { Extruder } from "./simple-extruder.js";
+export class ExtrudeTwoDistances extends ExtrudeBase {
+    distance1;
+    distance2;
+    constructor(distance1, distance2, extrudable) {
+        super(extrudable);
+        this.distance1 = distance1;
+        this.distance2 = distance2;
+    }
+    build(context) {
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        console.log("Extruding faces:", faces);
+        const extruder1 = new Extruder(faces, plane, this.distance1, this.getDraft(), this.getEndOffset());
+        const extrusions1 = extruder1.extrude();
+        const startFaces = extruder1.getEndFaces();
+        const extruder2 = new Extruder(faces, plane, -this.distance2, this.getDraft(), this.getEndOffset());
+        const extrusions2 = extruder2.extrude();
+        const endFaces = extruder2.getEndFaces();
+        const preFusionInternalFaces = [
+            ...extruder1.getInternalFaces(),
+            ...extruder2.getInternalFaces(),
+        ];
+        const all = [...extrusions1, ...extrusions2];
+        const { result: extrusions } = BooleanOps.fuse(all);
+        const sideFaces = [];
+        const internalFaces = [];
+        for (const solid of extrusions) {
+            const allFaces = Explorer.findFacesWrapped(solid);
+            for (const f of allFaces) {
+                const isStart = startFaces.some(sf => f.getShape().IsSame(sf.getShape()));
+                const isEnd = endFaces.some(ef => f.getShape().IsSame(ef.getShape()));
+                if (!isStart && !isEnd) {
+                    const isInternal = preFusionInternalFaces.some(pf => f.getShape().IsSame(pf.getShape()));
+                    if (isInternal) {
+                        internalFaces.push(f);
+                    }
+                    else {
+                        sideFaces.push(f);
+                    }
+                }
+            }
+        }
+        this.setState('start-faces', startFaces);
+        this.setState('end-faces', endFaces);
+        this.setState('side-faces', sideFaces);
+        this.setState('internal-faces', internalFaces);
+        this.extrudable.removeShapes(this);
+        if (this._operationMode === 'remove') {
+            const scope = this.resolveFusionScope(context.getSceneObjects());
+            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this);
+            return;
+        }
+        if (extrusions.length === 0 || sceneObjects.length === 0) {
+            this.addShapes(extrusions);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (!modifiedShape.object) {
+                continue;
+            }
+            modifiedShape.object.removeShape(modifiedShape.shape, this);
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    getDependencies() {
+        return this.extrudable ? [this.extrudable] : [];
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new ExtrudeTwoDistances(this.distance1, this.distance2, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof ExtrudeTwoDistances)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.distance1 !== other.distance1 || this.distance2 !== other.distance2) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        return 'extrude-by-two-distance';
+    }
+    serialize() {
+        return {
+            extrudable: this.extrudable.serialize(),
+            distance1: this.distance1,
+            distance2: this.distance2,
+            operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
+    }
+}

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

@@ -0,0 +1,25 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { ExtrudeBase } from "./extrude-base.js";
+export declare class Extrude extends ExtrudeBase {
+    distance: number;
+    constructor(distance: number, extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    private buildAdd;
+    private buildSymmetric;
+    private buildRemove;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Extrude): boolean;
+    getUniqueType(): string;
+    serialize(): {
+        extrudable: any;
+        distance: number;
+        operationMode: "new" | "remove";
+        symmetric: true;
+        draft: [number, number];
+        endOffset: number;
+        picking: true;
+        pickPoints: number[][];
+    };
+}