fluidcad 0.0.32 → 0.0.34

package/lib/dist/features/2d/back.js

@@ -9,8 +9,9 @@ export class Back extends GeometrySceneObject {
         return 'back';
     }
     build() {
-        const target = this.sketch.getPreviousPosition(this, this.count);
-        this.setCurrentPosition(target);
+        const { position, tangent } = this.sketch.getPreviousState(this, this.count);
+        this.setCurrentPosition(position);
+        this.setTangent(tangent);
     }
     getDependencies() {
         return [];

package/lib/dist/features/2d/sketch.d.ts

@@ -15,6 +15,10 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getTangentAt(currentObj: GeometrySceneObject): Point2D;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
     getPreviousPosition(currentObj: GeometrySceneObject, count?: number): Point2D;
+    getPreviousState(currentObj: GeometrySceneObject, count?: number): {
+        position: Point2D;
+        tangent: Point2D;
+    };
     getLastPosition(scope?: Set<SceneObject>): Point2D;
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];

package/lib/dist/features/2d/sketch.js

@@ -78,6 +78,27 @@ export class Sketch extends SceneObject {
         }
         return this.getStartPoint();
     }
+    getPreviousState(currentObj, count = 1) {
+        const children = this.getChildren();
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let remaining = count;
+        for (let i = previous.length - 1; i >= 0; i--) {
+            const pos = previous[i].getState('current-position');
+            if (pos) {
+                if (remaining === 0) {
+                    for (let j = i; j >= 0; j--) {
+                        const t = previous[j].getTangent();
+                        if (t) {
+                            return { position: pos, tangent: t };
+                        }
+                    }
+                    return { position: pos, tangent: new Point2D(1, 0) };
+                }
+                remaining--;
+            }
+        }
+        return { position: this.getStartPoint(), tangent: new Point2D(1, 0) };
+    }
     getLastPosition(scope) {
         let children = this.getChildren().slice();
         if (scope) {

package/lib/dist/features/2d/tarc-constrained.d.ts

@@ -1,4 +1,5 @@
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { ITangentArcTwoObjects } from "../../core/interfaces.js";
@@ -11,6 +12,7 @@ export declare class TangentArcTwoObjects extends GeometrySceneObject implements
     build(): void;
     start(index?: number): LazyVertex;
     end(index?: number): LazyVertex;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcTwoObjects): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-constrained.js

@@ -1,6 +1,7 @@
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
 export class TangentArcTwoObjects extends GeometrySceneObject {
     c1;
@@ -41,6 +42,13 @@ export class TangentArcTwoObjects extends GeometrySceneObject {
     end(index = 0) {
         return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
     }
+    createCopy(remap) {
+        const remappedC1Object = remap.get(this.c1.object) || this.c1.object;
+        const remappedC2Object = remap.get(this.c2.object) || this.c2.object;
+        const c1 = new QualifiedSceneObject(remappedC1Object, this.c1.qualifier);
+        const c2 = new QualifiedSceneObject(remappedC2Object, this.c2.qualifier);
+        return new TangentArcTwoObjects(c1, c2, this.radius, this.mustTouch);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcTwoObjects)) {
             return false;

package/lib/dist/features/2d/tarc-radius-to-object.d.ts

@@ -0,0 +1,16 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+export declare class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius: number;
+    target: QualifiedSceneObject;
+    constructor(radius: number, target: QualifiedSceneObject);
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcRadiusToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

package/lib/dist/features/2d/tarc-radius-to-object.js

@@ -0,0 +1,58 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { solveTangentArcRadiusToObject } from "../../oc/constraints/geometric/tangent-arc-radius-to-object.js";
+export class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius;
+    target;
+    constructor(radius, target) {
+        super();
+        this.radius = radius;
+        this.target = target;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const startTangent = this.sketch.getTangentAt(this);
+        const targetShape = this.target.toQualifiedShape();
+        const result = solveTangentArcRadiusToObject(plane, startPoint, startTangent, this.radius, targetShape);
+        for (let i = 0; i < result.edges.length; i++) {
+            this.setState(`edge-${i}`, result.edges[i]);
+        }
+        if (result.edges.length > 0) {
+            const lastEdge = result.edges[result.edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            if (result.endTangent) {
+                this.setTangent(result.endTangent);
+            }
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(result.edges);
+    }
+    createCopy(remap) {
+        const remappedObject = remap.get(this.target.object) || this.target.object;
+        const target = new QualifiedSceneObject(remappedObject, this.target.qualifier);
+        return new TangentArcRadiusToObject(this.radius, target);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcRadiusToObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius && this.target.compareTo(other.target);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-radius-to-object';
+    }
+    serialize() {
+        return { radius: this.radius };
+    }
+}

package/lib/dist/features/2d/tarc-to-object.d.ts

@@ -0,0 +1,18 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { ITangentArcToObject } from "../../core/interfaces.js";
+export declare class TangentArcToObject extends GeometrySceneObject implements ITangentArcToObject {
+    target: QualifiedSceneObject;
+    private flipped;
+    constructor(target: QualifiedSceneObject);
+    flip(): this;
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        flipped: boolean;
+    };
+}

package/lib/dist/features/2d/tarc-to-object.js

@@ -0,0 +1,66 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
+export class TangentArcToObject extends GeometrySceneObject {
+    target;
+    flipped = false;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    flip() {
+        this.flipped = true;
+        return this;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const startTangent = this.sketch.getTangentAt(this);
+        const targetShape = this.target.toQualifiedShape();
+        const solver = createConstraintSolver(false);
+        const result = solver.getTangentArcFromPointTangent(plane, startPoint, startTangent, targetShape, this.flipped);
+        for (let i = 0; i < result.edges.length; i++) {
+            this.setState(`edge-${i}`, result.edges[i]);
+        }
+        if (result.edges.length > 0) {
+            const lastEdge = result.edges[result.edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            if (result.endTangent) {
+                this.setTangent(result.endTangent);
+            }
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(result.edges);
+    }
+    createCopy(remap) {
+        const remappedObject = remap.get(this.target.object) || this.target.object;
+        const target = new QualifiedSceneObject(remappedObject, this.target.qualifier);
+        const copy = new TangentArcToObject(target);
+        if (this.flipped) {
+            copy.flip();
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcToObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.target.compareTo(other.target) && this.flipped === other.flipped;
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-to-object';
+    }
+    serialize() {
+        return { flipped: this.flipped };
+    }
+}

package/lib/dist/features/2d/tarc-to-point-tangent.d.ts

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 export declare class TangentArcToPointTangent extends GeometrySceneObject {
@@ -5,6 +6,7 @@ export declare class TangentArcToPointTangent extends GeometrySceneObject {
     startTangent: LazyVertex;
     constructor(endPoint: LazyVertex, startTangent: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcToPointTangent): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-to-point-tangent.js

@@ -62,6 +62,9 @@ export class TangentArcToPointTangent extends GeometrySceneObject {
         this.addShape(edge);
         this.setCurrentPosition(targetPoint);
     }
+    createCopy(remap) {
+        return new TangentArcToPointTangent(this.endPoint, this.startTangent);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcToPointTangent)) {
             return false;

package/lib/dist/features/2d/tarc-to-point.d.ts

@@ -1,9 +1,11 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 export declare class TangentArcToPoint extends GeometrySceneObject {
     endPoint: LazyVertex;
     constructor(endPoint: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcToPoint): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-to-point.js

@@ -60,6 +60,9 @@ export class TangentArcToPoint extends GeometrySceneObject {
         this.addShape(edge);
         this.setCurrentPosition(targetPoint);
     }
+    createCopy(remap) {
+        return new TangentArcToPoint(this.endPoint);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcToPoint)) {
             return false;

package/lib/dist/features/2d/tarc-with-tangent.d.ts

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class TangentArcWithTangent extends GeometrySceneObject {
@@ -6,6 +7,7 @@ export declare class TangentArcWithTangent extends GeometrySceneObject {
     startTangent: LazyVertex;
     constructor(radius: number, endAngle: number, startTangent: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcWithTangent): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-with-tangent.js

@@ -46,6 +46,9 @@ export class TangentArcWithTangent extends GeometrySceneObject {
         this.addShape(edge);
         this.setCurrentPosition(endPoint);
     }
+    createCopy(remap) {
+        return new TangentArcWithTangent(this.radius, this.endAngle, this.startTangent);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcWithTangent)) {
             return false;

package/lib/dist/features/2d/tarc.d.ts

@@ -1,9 +1,11 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class TangentArc extends GeometrySceneObject {
     radius: number;
     endAngle: number;
     constructor(radius: number, endAngle: number);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArc): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/2d/tarc.js

@@ -48,6 +48,9 @@ export class TangentArc extends GeometrySceneObject {
         this.addShape(edge);
         this.setCurrentPosition(endPoint);
     }
+    createCopy(remap) {
+        return new TangentArc(this.radius, this.endAngle);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArc)) {
             return false;

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

@@ -32,6 +32,15 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     get faceSource(): SceneObject | null;
     isFaceSourced(): boolean;
     getSource(): SceneObject | null;
+    /**
+     * Dependency tail for cloning: if the source is a sketch-bound geometry
+     * primitive, return its containing `Sketch` so cloneWithTransform pulls
+     * the sketch in too. The sketch's clone-mode build path then carries
+     * correctly-transformed shapes onto cloned children, and the cloned
+     * primitive retains a `Sketch` parent for plane resolution. Otherwise
+     * return the source as-is.
+     */
+    protected getSourceDependencies(): SceneObject[];
     getSourcePlane(): Plane | null;
     getSourceFaces(): Face[];
     startFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;

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

@@ -2,6 +2,7 @@ import { Face } from "../common/face.js";
 import { Edge } from "../common/edge.js";
 import { SceneObject } from "../common/scene-object.js";
 import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
 import { normalizePoint2D } from "../helpers/normalize.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
@@ -81,6 +82,27 @@ export class ExtrudeBase extends SceneObject {
     getSource() {
         return this._extrudable ?? this._faceSource;
     }
+    /**
+     * Dependency tail for cloning: if the source is a sketch-bound geometry
+     * primitive, return its containing `Sketch` so cloneWithTransform pulls
+     * the sketch in too. The sketch's clone-mode build path then carries
+     * correctly-transformed shapes onto cloned children, and the cloned
+     * primitive retains a `Sketch` parent for plane resolution. Otherwise
+     * return the source as-is.
+     */
+    getSourceDependencies() {
+        const source = this.getSource();
+        if (!source) {
+            return [];
+        }
+        if (source instanceof GeometrySceneObject) {
+            const sketch = source.sketch;
+            if (sketch) {
+                return [sketch];
+            }
+        }
+        return [source];
+    }
     getSourcePlane() {
         if (this._extrudable) {
             return this._extrudable.getPlane();

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

@@ -282,11 +282,7 @@ export class ExtrudeToFace extends ExtrudeBase {
         return objects;
     }
     getDependencies() {
-        const deps = [];
-        const source = this.getSource();
-        if (source) {
-            deps.push(source);
-        }
+        const deps = [...this.getSourceDependencies()];
         if (this.face instanceof SceneObject) {
             deps.push(this.face);
         }

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

@@ -158,8 +158,7 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.setFinalShapes(this.getShapes());
     }
     getDependencies() {
-        const source = this.getSource();
-        return source ? [source] : [];
+        return this.getSourceDependencies();
     }
     createCopy(remap) {
         const source = this.getSource();

package/lib/dist/features/extrude.js

@@ -286,8 +286,7 @@ export class Extrude extends ExtrudeBase {
         });
     }
     getDependencies() {
-        const source = this.getSource();
-        return source ? [source] : [];
+        return this.getSourceDependencies();
     }
     createCopy(remap) {
         const source = this.getSource();

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

@@ -1,7 +1,13 @@
 import { SceneObject } from "../common/scene-object.js";
 export declare class LoadFile extends SceneObject {
     fileName: string;
+    private _noColors;
+    private _include?;
+    private _exclude;
     constructor(fileName: string);
+    noColors(): this;
+    include(...indices: number[]): this;
+    exclude(...indices: number[]): this;
     build(): void;
     compareTo(other: LoadFile): boolean;
     getType(): string;

package/lib/dist/features/load.js

@@ -2,12 +2,38 @@ import { SceneObject } from "../common/scene-object.js";
 import { FileImport } from "../io/file-import.js";
 export class LoadFile extends SceneObject {
     fileName;
+    _noColors = false;
+    _include;
+    _exclude = new Set();
     constructor(fileName) {
         super();
         this.fileName = fileName;
     }
+    noColors() {
+        this._noColors = true;
+        return this;
+    }
+    include(...indices) {
+        if (!this._include) {
+            this._include = new Set();
+        }
+        for (const i of indices) {
+            this._include.add(i);
+        }
+        return this;
+    }
+    exclude(...indices) {
+        for (const i of indices) {
+            this._exclude.add(i);
+        }
+        return this;
+    }
     build() {
-        const shapes = FileImport.deserializeShapesWithMetadata(this.fileName);
+        const shapes = FileImport.deserializeShapesWithMetadata(this.fileName, {
+            noColors: this._noColors,
+            include: this._include,
+            exclude: this._exclude.size > 0 ? this._exclude : undefined,
+        });
         this.addShapes(shapes);
     }
     compareTo(other) {
@@ -20,6 +46,15 @@ export class LoadFile extends SceneObject {
         if (this.fileName !== other.fileName) {
             return false;
         }
+        if (this._noColors !== other._noColors) {
+            return false;
+        }
+        if (!equalSets(this._include, other._include)) {
+            return false;
+        }
+        if (!equalSets(this._exclude, other._exclude)) {
+            return false;
+        }
         return true;
     }
     getType() {
@@ -29,3 +64,20 @@ export class LoadFile extends SceneObject {
         return {};
     }
 }
+function equalSets(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const v of a) {
+        if (!b.has(v)) {
+            return false;
+        }
+    }
+    return true;
+}

package/lib/dist/features/mirror-feature.d.ts

@@ -1,10 +1,11 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 export declare class MirrorFeature extends SceneObject {
     private plane;
-    private _matrix?;
-    constructor(plane: PlaneObjectBase, _matrix?: Matrix4);
+    private _matrix;
+    constructor(plane: PlaneObjectBase, _matrix: LazyMatrix);
     getTransformMatrix(): Matrix4 | null;
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;

package/lib/dist/features/mirror-feature.js

@@ -9,7 +9,7 @@ export class MirrorFeature extends SceneObject {
         this.setAlwaysVisible();
     }
     getTransformMatrix() {
-        return this._matrix || null;
+        return this._matrix.resolve();
     }
     isContainer() {
         return true;

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

@@ -1,5 +1,5 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { Axis } from "../math/axis.js";
+import { RepeatAxisSource } from "./repeat-linear.js";
 export type CircularRepeatOptions = {
     count: number;
     centered?: boolean;
@@ -12,10 +12,10 @@ export type CircularRepeatOptions = {
     offset?: never;
 });
 export declare class RepeatCircular extends SceneObject {
-    axis: Axis;
+    axis: RepeatAxisSource;
     options: CircularRepeatOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axis: Axis, options: CircularRepeatOptions, targetObjects?: SceneObject[] | null);
+    constructor(axis: RepeatAxisSource, options: CircularRepeatOptions, targetObjects?: SceneObject[] | null);
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: RepeatCircular): boolean;

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

@@ -1,4 +1,8 @@
 import { SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+function axisOf(source) {
+    return source instanceof AxisObjectBase ? source.getAxis() : source;
+}
 export class RepeatCircular extends SceneObject {
     axis;
     options;
@@ -14,6 +18,9 @@ export class RepeatCircular extends SceneObject {
         return true;
     }
     build(context) {
+        if (this.axis instanceof AxisObjectBase) {
+            this.axis.removeShapes(this);
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {
@@ -23,7 +30,7 @@ export class RepeatCircular extends SceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (!this.axis.equals(other.axis)) {
+        if (!axisOf(this.axis).equals(axisOf(other.axis))) {
             return false;
         }
         const thisTargetObjects = this.targetObjects || [];

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

@@ -1,5 +1,7 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Axis } from "../math/axis.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+export type RepeatAxisSource = Axis | AxisObjectBase;
 export type LinearRepeatOptions = {
     count: number | number[];
     centered?: boolean;
@@ -12,10 +14,10 @@ export type LinearRepeatOptions = {
     offset?: never;
 });
 export declare class RepeatLinear extends SceneObject {
-    axes: Axis[];
+    axes: RepeatAxisSource[];
     options: LinearRepeatOptions;
     targetObjects: SceneObject[] | null;
-    constructor(axes: Axis[], options: LinearRepeatOptions, targetObjects?: SceneObject[] | null);
+    constructor(axes: RepeatAxisSource[], options: LinearRepeatOptions, targetObjects?: SceneObject[] | null);
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;
     compareTo(other: RepeatLinear): boolean;

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

@@ -1,4 +1,8 @@
 import { SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+function axisOf(source) {
+    return source instanceof AxisObjectBase ? source.getAxis() : source;
+}
 export class RepeatLinear extends SceneObject {
     axes;
     options;
@@ -14,6 +18,11 @@ export class RepeatLinear extends SceneObject {
         return true;
     }
     build(context) {
+        for (const axis of this.axes) {
+            if (axis instanceof AxisObjectBase) {
+                axis.removeShapes(this);
+            }
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {
@@ -27,7 +36,7 @@ export class RepeatLinear extends SceneObject {
             return false;
         }
         for (let i = 0; i < this.axes.length; i++) {
-            if (!this.axes[i].equals(other.axes[i])) {
+            if (!axisOf(this.axes[i]).equals(axisOf(other.axes[i]))) {
                 return false;
             }
         }