fluidcad 0.0.2 → 0.0.4

package/lib/dist/features/2d/tarc-two-circles.js

@@ -1,61 +0,0 @@
-import { GeometrySceneObject } from "./geometry.js";
-import { LazyVertex } from "../lazy-vertex.js";
-import { Vertex } from "../../common/vertex.js";
-import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
-export class TangentArcTwoObjects extends GeometrySceneObject {
-    c1;
-    c2;
-    radius;
-    constructor(c1, c2, radius) {
-        super();
-        this.c1 = c1;
-        this.c2 = c2;
-        this.radius = radius;
-    }
-    build() {
-        const plane = this.sketch.getPlane();
-        const solver = createConstraintSolver();
-        const results = solver.getTangentArcs(plane, this.c1.toQualifiedShape(), this.c2.toQualifiedShape(), this.radius);
-        for (let i = 0; i < results.edges.length; i++) {
-            this.setState(`edge-${i}`, results.edges[i]);
-        }
-        if (results.edges.length > 0) {
-            const lastEdge = results.edges[results.edges.length - 1];
-            const endTangent = results.endTangent;
-            const firstVertex = lastEdge.getFirstVertex();
-            const lastVertex = lastEdge.getLastVertex();
-            const localStart = plane.worldToLocal(firstVertex.toPoint());
-            const localEnd = plane.worldToLocal(lastVertex.toPoint());
-            this.setState('start', Vertex.fromPoint2D(localStart));
-            this.setState('end', Vertex.fromPoint2D(localEnd));
-            this.setTangent(endTangent);
-            this.setCurrentPosition(localEnd);
-        }
-        this.addShapes(results.edges);
-    }
-    start(index = 0) {
-        return new LazyVertex(this.generateUniqueName(`start-vertex-${index}`), () => [this.getState('start')]);
-    }
-    end(index = 0) {
-        return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
-    }
-    compareTo(other) {
-        if (!(other instanceof TangentArcTwoObjects)) {
-            return false;
-        }
-        return this.c1.compareTo(other.c1) &&
-            this.c2.compareTo(other.c2) &&
-            this.radius === other.radius;
-    }
-    getType() {
-        return 'tarc';
-    }
-    getUniqueType() {
-        return 'two-objects-tarc';
-    }
-    serialize() {
-        return {
-            radius: this.radius
-        };
-    }
-}

package/lib/dist/features/2d/tcircle-three-tan.d.ts

@@ -1,13 +0,0 @@
-import { GeometrySceneObject } from "./geometry.js";
-import { QualifiedGeometry } from "./constraints/qualified-geometry.js";
-export declare class TangentCircle3Tan extends GeometrySceneObject {
-    c1: QualifiedGeometry;
-    c2: QualifiedGeometry;
-    c3: QualifiedGeometry;
-    constructor(c1: QualifiedGeometry, c2: QualifiedGeometry, c3: QualifiedGeometry);
-    build(): void;
-    compareTo(other: TangentCircle3Tan): boolean;
-    getType(): string;
-    getUniqueType(): string;
-    serialize(): {};
-}

package/lib/dist/features/2d/tcircle-three-tan.js

@@ -1,33 +0,0 @@
-import { GeometrySceneObject } from "./geometry.js";
-import { TangentSolver } from "../../oc/tangent-solver.js";
-export class TangentCircle3Tan extends GeometrySceneObject {
-    c1;
-    c2;
-    c3;
-    constructor(c1, c2, c3) {
-        super();
-        this.c1 = c1;
-        this.c2 = c2;
-        this.c3 = c3;
-    }
-    build() {
-        const plane = this.sketch.getPlane();
-        const edges = TangentSolver.getTangentCircles3Tan(plane, this.c1, this.c2, this.c3);
-        this.addShapes(edges);
-    }
-    compareTo(other) {
-        if (!(other instanceof TangentCircle3Tan)) {
-            return false;
-        }
-        return this.c1.compareTo(other.c1) && this.c2.compareTo(other.c2) && this.c3.compareTo(other.c3);
-    }
-    getType() {
-        return 'circle';
-    }
-    getUniqueType() {
-        return 'tcircle-3tan';
-    }
-    serialize() {
-        return {};
-    }
-}

package/lib/dist/features/2d/tcircle-two-tan.d.ts

@@ -1,13 +0,0 @@
-import { GeometrySceneObject } from "./geometry.js";
-import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
-export declare class TwoObjectsTangentCircle extends GeometrySceneObject {
-    c1: QualifiedSceneObject;
-    c2: QualifiedSceneObject;
-    radius: number;
-    constructor(c1: QualifiedSceneObject, c2: QualifiedSceneObject, radius: number);
-    build(): void;
-    compareTo(other: TwoObjectsTangentCircle): boolean;
-    getType(): string;
-    getUniqueType(): string;
-    serialize(): {};
-}

package/lib/dist/features/2d/tcircle-two-tan.js

@@ -1,33 +0,0 @@
-import { GeometrySceneObject } from "./geometry.js";
-import { TangentSolver } from "../../oc/tangent-solver.js";
-export class TwoObjectsTangentCircle extends GeometrySceneObject {
-    c1;
-    c2;
-    radius;
-    constructor(c1, c2, radius) {
-        super();
-        this.c1 = c1;
-        this.c2 = c2;
-        this.radius = radius;
-    }
-    build() {
-        const plane = this.sketch.getPlane();
-        const edges = TangentSolver.getTangentCircles(plane, this.c1, this.c2, this.radius);
-        this.addShapes(edges);
-    }
-    compareTo(other) {
-        if (!(other instanceof TwoObjectsTangentCircle)) {
-            return false;
-        }
-        return super.compareTo(other) && this.c1.compareTo(other.c1) && this.c2.compareTo(other.c2) && this.radius === other.radius;
-    }
-    getType() {
-        return 'circle';
-    }
-    getUniqueType() {
-        return 'two-objects-tcircle';
-    }
-    serialize() {
-        return {};
-    }
-}

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

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

package/lib/dist/features/Extrude.js

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

package/lib/dist/features/cut-base.d.ts

@@ -1,49 +0,0 @@
-import { Face } from "../common/face.js";
-import { Shape } from "../common/shape.js";
-import { SceneObject } from "../common/scene-object.js";
-import { ExtrudeOptions } from "./extrude-options.js";
-import { Extrudable } from "../helpers/types.js";
-import { LazyVertex } from "./lazy-vertex.js";
-import { ICut } from "../core/interfaces.js";
-import { Point2DLike } from "../math/point.js";
-import { Plane } from "../math/plane.js";
-import { FaceFilterBuilder } from "../filters/face/face-filter.js";
-import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
-export interface CutOptions extends ExtrudeOptions {
-}
-export declare abstract class CutBase extends SceneObject implements ICut {
-    protected _extrudable: Extrudable | null;
-    protected _draft?: number | [number, number];
-    protected _endOffset?: number;
-    protected _picking: boolean;
-    protected _pickPoints: LazyVertex[];
-    constructor(extrudable?: Extrudable);
-    get extrudable(): Extrudable;
-    draft(value: number | [number, number]): this;
-    endOffset(value: number): this;
-    getDraft(): [number, number];
-    getEndOffset(): number | undefined;
-    pick(...points: Point2DLike[]): this;
-    isPicking(): boolean;
-    getPickPoints(): LazyVertex[];
-    protected resolvePickedFaces(plane: Plane): Face[] | null;
-    removeMetaShapes(removedBy: SceneObject): void;
-    clean(allObjects: SceneObject[]): void;
-    /**
-     * Classifies edges and faces from cleaned result shapes by comparing with
-     * original stock shapes. Edges/faces not present in stock are "section" geometry
-     * created by the cut. Section edges are further classified by signed distance
-     * from the cut plane into start, end, and internal groups.
-     */
-    protected classifyCutResult(stockShapes: Shape[], cleanedShapes: Shape[], plane: Plane, cutDistance: number): void;
-    protected syncWith(other: CutBase): this;
-    compareTo(other: CutBase): boolean;
-    startEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    endEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    internalEdges(...args: (number | EdgeFilterBuilder)[]): SceneObject;
-    internalFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
-    private buildSuffix;
-    private resolveEdges;
-    private resolveFaces;
-    getType(): string;
-}

package/lib/dist/features/cut-base.js

@@ -1,312 +0,0 @@
-import { SceneObject } from "../common/scene-object.js";
-import { LazySelectionSceneObject } from "./lazy-scene-object.js";
-import { normalizePoint2D } from "../helpers/normalize.js";
-import { FaceOps } from "../oc/face-ops.js";
-import { FaceMaker2 } from "../oc/face-maker2.js";
-import { EdgeOps } from "../oc/edge-ops.js";
-import { Explorer } from "../oc/explorer.js";
-import { FaceFilterBuilder } from "../filters/face/face-filter.js";
-import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
-import { ShapeFilter } from "../filters/filter.js";
-export class CutBase extends SceneObject {
-    _extrudable = null;
-    _draft;
-    _endOffset;
-    _picking = false;
-    _pickPoints = [];
-    constructor(extrudable) {
-        super();
-        this._extrudable = extrudable ?? null;
-    }
-    get extrudable() {
-        return this._extrudable;
-    }
-    draft(value) {
-        this._draft = value;
-        return this;
-    }
-    endOffset(value) {
-        this._endOffset = value;
-        return this;
-    }
-    getDraft() {
-        const draft = this._draft;
-        if (!draft) {
-            return null;
-        }
-        return draft instanceof Array ? draft : [draft, draft];
-    }
-    getEndOffset() {
-        return this._endOffset;
-    }
-    pick(...points) {
-        this._picking = true;
-        this._pickPoints = points.map(p => normalizePoint2D(p));
-        return this;
-    }
-    isPicking() {
-        return this._picking;
-    }
-    getPickPoints() {
-        return this._pickPoints;
-    }
-    resolvePickedFaces(plane) {
-        if (!this.isPicking()) {
-            return null;
-        }
-        const sketchShapes = this.extrudable.getGeometries();
-        const cells = FaceMaker2.getRegions(sketchShapes, plane, false);
-        if (cells.length === 0) {
-            return [];
-        }
-        const pickPoints = this.getPickPoints();
-        const selectedCells = [];
-        for (const cell of cells) {
-            let isSelected = false;
-            let pickPoint = null;
-            for (const lazyPt of pickPoints) {
-                const pt2d = lazyPt.asPoint2D();
-                const pt3d = plane.localToWorld(pt2d);
-                if (FaceOps.isPointInsideFace(pt3d, cell)) {
-                    isSelected = true;
-                    pickPoint = [pt2d.x, pt2d.y];
-                    break;
-                }
-            }
-            if (isSelected) {
-                cell.markAsMetaShape('pick-region-selected');
-                cell.metaData = { pickPoint };
-                selectedCells.push(cell);
-            }
-            else {
-                cell.markAsMetaShape('pick-region');
-            }
-            this.addShape(cell);
-            for (const edge of cell.getEdges()) {
-                edge.markAsMetaShape('pick-edge');
-                this.addShape(edge);
-            }
-        }
-        return selectedCells;
-    }
-    removeMetaShapes(removedBy) {
-        for (const shape of this.getAddedShapes()) {
-            if (shape.isMetaShape()) {
-                this.removeShape(shape, removedBy);
-            }
-        }
-    }
-    clean(allObjects) {
-        if (!this.isPicking()) {
-            return;
-        }
-        const lastObject = allObjects[allObjects.length - 1];
-        if (lastObject !== this) {
-            this.removeMetaShapes(lastObject);
-        }
-    }
-    /**
-     * Classifies edges and faces from cleaned result shapes by comparing with
-     * original stock shapes. Edges/faces not present in stock are "section" geometry
-     * created by the cut. Section edges are further classified by signed distance
-     * from the cut plane into start, end, and internal groups.
-     */
-    classifyCutResult(stockShapes, cleanedShapes, plane, cutDistance) {
-        // Collect stock edge midpoints for geometric comparison
-        const stockEdgeMidpoints = [];
-        for (const stock of stockShapes) {
-            const edges = Explorer.findEdgesWrapped(stock);
-            for (const edge of edges) {
-                stockEdgeMidpoints.push(EdgeOps.getEdgeMidPoint(edge));
-            }
-        }
-        const tolerance = 1e-6;
-        const isStockEdge = (edge) => {
-            const mid = EdgeOps.getEdgeMidPoint(edge);
-            return stockEdgeMidpoints.some(sm => Math.abs(mid.x - sm.x) < tolerance &&
-                Math.abs(mid.y - sm.y) < tolerance &&
-                Math.abs(mid.z - sm.z) < tolerance);
-        };
-        // Find section edges from cleaned result (edges not in stock)
-        const sectionEdges = [];
-        const sectionEdgeSet = new Set();
-        for (const shape of cleanedShapes) {
-            const edges = Explorer.findEdgesWrapped(shape);
-            for (const edge of edges) {
-                if (!isStockEdge(edge)) {
-                    sectionEdges.push(edge);
-                    sectionEdgeSet.add(edge);
-                }
-            }
-        }
-        // Internal faces: faces where ALL edges are section edges (not from stock).
-        // Modified stock faces (e.g., top face with holes) still have stock edges
-        // on their outer boundary, so they are correctly excluded.
-        const internalFaces = [];
-        for (const shape of cleanedShapes) {
-            const faces = Explorer.findFacesWrapped(shape);
-            for (const f of faces) {
-                const faceEdges = f.getEdges();
-                if (faceEdges.length > 0 && faceEdges.every(e => !isStockEdge(e))) {
-                    internalFaces.push(f);
-                }
-            }
-        }
-        // Classify section edges by signed distance from cut plane
-        const startEdges = [];
-        const endEdges = [];
-        const internalEdges = [];
-        if (plane && sectionEdges.length > 0) {
-            const isThroughAll = cutDistance === 0;
-            const dists = sectionEdges.map(edge => ({
-                edge,
-                d: plane.signedDistanceToPoint(EdgeOps.getEdgeMidPoint(edge))
-            }));
-            const startDist = isThroughAll ? Math.max(...dists.map(e => e.d)) : 0;
-            const endDist = isThroughAll ? Math.min(...dists.map(e => e.d)) : -cutDistance;
-            const distTolerance = 1e-4;
-            for (const { edge, d } of dists) {
-                if (Math.abs(d - startDist) < distTolerance) {
-                    startEdges.push(edge);
-                }
-                else if (Math.abs(d - endDist) < distTolerance) {
-                    endEdges.push(edge);
-                }
-                else {
-                    internalEdges.push(edge);
-                }
-            }
-        }
-        this.setState('section-edges', sectionEdges);
-        this.setState('start-edges', startEdges);
-        this.setState('end-edges', endEdges);
-        this.setState('internal-edges', internalEdges);
-        this.setState('internal-faces', internalFaces);
-    }
-    syncWith(other) {
-        this._draft = other._draft;
-        this._endOffset = other._endOffset;
-        this._fusionScope = other.getFusionScope();
-        this._picking = other._picking;
-        this._pickPoints = other._pickPoints;
-        return this;
-    }
-    compareTo(other) {
-        if (!super.compareTo(other)) {
-            return false;
-        }
-        if (this._fusionScope !== other._fusionScope
-            || this._endOffset !== other._endOffset) {
-            return false;
-        }
-        if (this._picking !== other._picking) {
-            return false;
-        }
-        if (this._pickPoints.length !== other._pickPoints.length) {
-            return false;
-        }
-        for (let i = 0; i < this._pickPoints.length; i++) {
-            if (!this._pickPoints[i].compareTo(other._pickPoints[i])) {
-                return false;
-            }
-        }
-        let thisDraft = this._draft || [0, 0];
-        let otherDraft = other._draft || [0, 0];
-        thisDraft = this._draft instanceof Array ? this._draft : [this._draft, this._draft];
-        otherDraft = other._draft instanceof Array ? other._draft : [other._draft, other._draft];
-        if (thisDraft[0] !== otherDraft[0] || thisDraft[1] !== otherDraft[1]) {
-            return false;
-        }
-        return true;
-    }
-    startEdges(...args) {
-        const suffix = this.buildSuffix('start-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const edges = parent.getState('start-edges') || [];
-            const transform = parent.getTransform();
-            const originalEdges = transform
-                ? (this.getState('start-edges') || [])
-                : null;
-            return this.resolveEdges(edges, args, transform, originalEdges);
-        }, this);
-    }
-    endEdges(...args) {
-        const suffix = this.buildSuffix('end-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const edges = parent.getState('end-edges') || [];
-            const transform = parent.getTransform();
-            const originalEdges = transform
-                ? (this.getState('end-edges') || [])
-                : null;
-            return this.resolveEdges(edges, args, transform, originalEdges);
-        }, this);
-    }
-    internalEdges(...args) {
-        const suffix = this.buildSuffix('internal-edges', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const edges = parent.getState('internal-edges') || [];
-            const transform = parent.getTransform();
-            const originalEdges = transform
-                ? (this.getState('internal-edges') || [])
-                : null;
-            return this.resolveEdges(edges, args, transform, originalEdges);
-        }, this);
-    }
-    internalFaces(...args) {
-        const suffix = this.buildSuffix('internal-faces', args);
-        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('internal-faces') || [];
-            const transform = parent.getTransform();
-            const originalFaces = transform
-                ? (this.getState('internal-faces') || [])
-                : null;
-            return this.resolveFaces(faces, args, transform, originalFaces);
-        }, this);
-    }
-    buildSuffix(prefix, args) {
-        if (args.length === 0) {
-            return prefix;
-        }
-        const key = args.map(a => typeof a === 'number' ? a : 'f').join('-');
-        return `${prefix}-${key}`;
-    }
-    resolveEdges(shapes, args, transform = null, originalShapes = null) {
-        if (args.length === 0) {
-            return shapes;
-        }
-        if (args.every(a => typeof a === 'number')) {
-            const indices = args;
-            let filters = indices.map(i => new EdgeFilterBuilder().atIndex(i, shapes, originalShapes));
-            if (transform) {
-                filters = filters.map(f => f.transform(transform));
-            }
-            return new ShapeFilter(shapes, ...filters).apply();
-        }
-        let filters = args.filter(a => a instanceof EdgeFilterBuilder);
-        if (transform) {
-            filters = filters.map(f => f.transform(transform));
-        }
-        return new ShapeFilter(shapes, ...filters).apply();
-    }
-    resolveFaces(shapes, args, transform = null, originalShapes = null) {
-        if (args.length === 0) {
-            return shapes;
-        }
-        if (args.every(a => typeof a === 'number')) {
-            const indices = args;
-            let filters = indices.map(i => new FaceFilterBuilder().atIndex(i, shapes, originalShapes));
-            if (transform) {
-                filters = filters.map(f => f.transform(transform));
-            }
-            return new ShapeFilter(shapes, ...filters).apply();
-        }
-        let filters = args.filter(a => a instanceof FaceFilterBuilder);
-        if (transform) {
-            filters = filters.map(f => f.transform(transform));
-        }
-        return new ShapeFilter(shapes, ...filters).apply();
-    }
-    getType() {
-        return "cut";
-    }
-}

package/lib/dist/features/cut-symmetric.d.ts

@@ -1,23 +0,0 @@
-import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Extrudable } from "../helpers/types.js";
-import { CutBase } from "./cut-base.js";
-export declare class CutSymmetric extends CutBase {
-    distance: number;
-    constructor(distance: number, extrudable?: Extrudable);
-    build(context: BuildSceneObjectContext): void;
-    getDependencies(): SceneObject[];
-    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
-    compareTo(other: CutSymmetric): boolean;
-    edges(...indices: number[]): SceneObject;
-    getType(): string;
-    serialize(): {
-        extrudable: any;
-        distance: number;
-        symmetric: boolean;
-        draft: [number, number];
-        endOffset: number;
-        fusionScope: import("./extrude-options.js").FusionScope;
-        picking: true;
-        pickPoints: number[][];
-    };
-}

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

@@ -1,119 +0,0 @@
-import { BooleanOps } from "../oc/boolean-ops.js";
-import { ShapeOps } from "../oc/shape-ops.js";
-import { ExtrudeOps } from "../oc/extrude-ops.js";
-import { ExtrudeThroughAll } from "./infinite-extrude.js";
-import { LazySelectionSceneObject } from "./lazy-scene-object.js";
-import { CutBase } from "./cut-base.js";
-import { FaceMaker2 } from "../oc/face-maker2.js";
-export class CutSymmetric extends CutBase {
-    distance;
-    constructor(distance, extrudable) {
-        super(extrudable);
-        this.distance = distance;
-    }
-    build(context) {
-        const plane = this.extrudable.getPlane();
-        const pickedFaces = this.resolvePickedFaces(plane);
-        if (pickedFaces !== null && pickedFaces.length === 0) {
-            return;
-        }
-        const scope = this.resolveFusionScope(context.getSceneObjects());
-        const sceneObjects = new Map();
-        for (const obj of scope) {
-            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
-            if (shapes.length === 0) {
-                continue;
-            }
-            sceneObjects.set(obj, shapes);
-        }
-        let toolShapes;
-        const isThroughAll = this.distance === 0;
-        if (isThroughAll && !pickedFaces) {
-            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, false);
-            toolShapes = extrudeThroughAll.build();
-        }
-        else {
-            const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
-            const effectiveDistance = isThroughAll ? 10000 : this.distance;
-            const vec = plane.normal.multiply(effectiveDistance);
-            const translateVec = vec.multiply(-0.5);
-            toolShapes = [];
-            for (const face of faces) {
-                const { solid: rawSolid } = ExtrudeOps.makePrismFromVec(face, vec);
-                const solid = ShapeOps.translateShape(ShapeOps.cleanShape(rawSolid), translateVec);
-                toolShapes.push(solid);
-            }
-        }
-        this.extrudable.removeShapes(this);
-        const shapeObjectMap = new Map();
-        for (const [obj, shapes] of sceneObjects) {
-            for (const shape of shapes) {
-                shapeObjectMap.set(shape, obj);
-            }
-        }
-        const stock = Array.from(shapeObjectMap.keys());
-        const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, this.distance);
-        const cleanedShapes = [];
-        for (const shape of stock) {
-            const list = cutResult.modified(shape);
-            if (list.length) {
-                for (const newShape of list) {
-                    const s = ShapeOps.cleanShape(newShape);
-                    this.addShape(s);
-                    cleanedShapes.push(s);
-                }
-                const obj = shapeObjectMap.get(shape);
-                obj.removeShape(shape, this);
-            }
-        }
-        this.classifyCutResult(stock, cleanedShapes, plane, this.distance);
-    }
-    getDependencies() {
-        return this.extrudable ? [this.extrudable] : [];
-    }
-    createCopy(remap) {
-        const extrudable = this.extrudable
-            ? (remap.get(this.extrudable) || this.extrudable)
-            : undefined;
-        return new CutSymmetric(this.distance, extrudable).syncWith(this);
-    }
-    compareTo(other) {
-        if (!(other instanceof CutSymmetric)) {
-            return false;
-        }
-        if (!super.compareTo(other)) {
-            return false;
-        }
-        if (this.distance !== other.distance) {
-            return false;
-        }
-        return true;
-    }
-    edges(...indices) {
-        const suffix = indices.length > 0 ? `section-edges-${indices.join('-')}` : 'section-edges';
-        return new LazySelectionSceneObject(`${this.getOrder()}-cut-symmetric-${suffix}`, (parent) => {
-            const edges = parent.getState('section-edges') || [];
-            if (indices.length === 0) {
-                return edges;
-            }
-            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
-        }, this);
-    }
-    getType() {
-        return "cut-symmetric";
-    }
-    serialize() {
-        return {
-            extrudable: this.extrudable.serialize(),
-            distance: this.distance,
-            symmetric: true,
-            draft: this.getDraft(),
-            endOffset: this.getEndOffset(),
-            fusionScope: this.getFusionScope(),
-            picking: this.isPicking() || undefined,
-            pickPoints: this.isPicking()
-                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
-                : undefined,
-        };
-    }
-}