fluidcad 0.0.33 → 0.0.34

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/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;
             }
         }

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

@@ -1,9 +1,11 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 export declare class RepeatMatrix extends SceneObject {
     private _matrix;
     targetObjects: SceneObject[];
-    constructor(_matrix: Matrix4, targetObjects: SceneObject[]);
+    private sources;
+    constructor(_matrix: LazyMatrix, targetObjects: SceneObject[], sources?: SceneObject[]);
     getTransformMatrix(): Matrix4 | null;
     isContainer(): boolean;
     build(context: BuildSceneObjectContext): void;

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

@@ -2,19 +2,24 @@ import { SceneObject } from "../common/scene-object.js";
 export class RepeatMatrix extends SceneObject {
     _matrix;
     targetObjects;
-    constructor(_matrix, targetObjects) {
+    sources;
+    constructor(_matrix, targetObjects, sources = []) {
         super();
         this._matrix = _matrix;
         this.targetObjects = targetObjects;
+        this.sources = sources;
         this.setAlwaysVisible();
     }
     getTransformMatrix() {
-        return this._matrix;
+        return this._matrix.resolve();
     }
     isContainer() {
         return true;
     }
     build(context) {
+        for (const source of this.sources) {
+            source.removeShapes(this);
+        }
         this.saveShapesSnapshot(context);
     }
     compareTo(other) {

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

@@ -2,12 +2,14 @@ import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js"
 import { SelectSceneObject } from "./select.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
-import { IShell } from "../core/interfaces.js";
+import { IShell, ShellJoinType } from "../core/interfaces.js";
 export declare class Shell extends SceneObject implements IShell {
     private thickness;
     private _faceSelections;
+    private _joinType;
     constructor(thickness: number, faceSelections?: SelectSceneObject[]);
     get faceSelections(): SelectSceneObject[];
+    join(type: ShellJoinType): this;
     validate(): void;
     build(context: BuildSceneObjectContext): void;
     internalFaces(...args: (number | FaceFilterBuilder)[]): SceneObject;
@@ -21,5 +23,6 @@ export declare class Shell extends SceneObject implements IShell {
     getType(): string;
     serialize(): {
         thickness: number;
+        joinType: "intersection" | "tangent";
     };
 }

package/lib/dist/features/shell.js

@@ -11,6 +11,7 @@ import { requireShapes } from "../common/operand-check.js";
 export class Shell extends SceneObject {
     thickness;
     _faceSelections = [];
+    _joinType = 'arc';
     constructor(thickness, faceSelections) {
         super();
         this.thickness = thickness;
@@ -19,6 +20,10 @@ export class Shell extends SceneObject {
     get faceSelections() {
         return this._faceSelections;
     }
+    join(type) {
+        this._joinType = type;
+        return this;
+    }
     validate() {
         for (let i = 0; i < this._faceSelections.length; i++) {
             requireShapes(this._faceSelections[i], `face selection ${i + 1}`, "shell");
@@ -52,7 +57,7 @@ export class Shell extends SceneObject {
                 continue;
             }
             try {
-                const newShape = ShellOps.makeThickSolid(shape, targetFaces, this.thickness);
+                const newShape = ShellOps.makeThickSolid(shape, targetFaces, this.thickness, this._joinType);
                 newShapes.push(newShape);
                 const originalObj = shapeObjMap.get(shape);
                 originalObj.removeShape(shape, this);
@@ -192,6 +197,9 @@ export class Shell extends SceneObject {
         if (this.thickness !== other.thickness) {
             return false;
         }
+        if (this._joinType !== other._joinType) {
+            return false;
+        }
         if (this._faceSelections.length !== other._faceSelections.length) {
             return false;
         }
@@ -207,14 +215,17 @@ export class Shell extends SceneObject {
     }
     createCopy(remap) {
         const faceSelections = this._faceSelections.map(sel => (remap.get(sel) || sel));
-        return new Shell(this.thickness, faceSelections.length > 0 ? faceSelections : undefined);
+        const copy = new Shell(this.thickness, faceSelections.length > 0 ? faceSelections : undefined);
+        copy._joinType = this._joinType;
+        return copy;
     }
     getType() {
         return 'shell';
     }
     serialize() {
         return {
-            thickness: this.thickness
+            thickness: this.thickness,
+            joinType: this._joinType !== 'arc' ? this._joinType : undefined
         };
     }
 }

package/lib/dist/helpers/clone-transform.d.ts

@@ -1,3 +1,4 @@
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { SceneObject } from "../common/scene-object.js";
-export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4, container: SceneObject): SceneObject[];
+export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4 | LazyMatrix, container: SceneObject): SceneObject[];

package/lib/dist/index.d.ts

@@ -17,7 +17,13 @@ export type SceneParserContext = {
     getActiveSketch(): Sketch | null;
 };
 export declare function registerBuilder<T extends Function>(builder: (context: SceneParserContext) => T): T;
-export declare function init(rootPath?: string): Promise<{
+export interface FluidCADOptions {
+    mesh?: {
+        lineDeflection?: number;
+        angularDeflection?: number;
+    };
+}
+export declare function init(options?: FluidCADOptions): Promise<{
     currentScene: Scene;
     currentFile: string;
     renderer: import("./rendering/render.js").SceneRenderer;

package/lib/dist/index.js

@@ -88,8 +88,8 @@ export function registerBuilder(builder) {
     return fn;
     ;
 }
-export async function init(rootPath) {
+export async function init(options) {
     await loadOC();
-    const resolvedPath = rootPath || process.env.FLUIDCAD_WORKSPACE_PATH || '';
-    return createManager(resolvedPath);
+    const resolvedPath = process.env.FLUIDCAD_WORKSPACE_PATH || '';
+    return createManager(resolvedPath, options);
 }

package/lib/dist/math/lazy-matrix.d.ts

@@ -0,0 +1,31 @@
+import { Matrix4 } from "./matrix4.js";
+import { Axis } from "./axis.js";
+import { Plane } from "./plane.js";
+/** Anything that can be resolved to an `Axis` once built — e.g. `AxisObjectBase`. */
+export interface AxisLazySource {
+    getAxis(): Axis;
+}
+/** Anything that can be resolved to a `Plane` once built — e.g. `PlaneObjectBase`. */
+export interface PlaneLazySource {
+    getPlane(): Plane;
+}
+/**
+ * Memoized thunk over a Matrix4. Lets parse-time code thread a transform
+ * value that depends on scene state (e.g. an AxisObjectBase or
+ * PlaneObjectBase) before that state exists. Resolution is deferred to the
+ * first call to `resolve()`, by which point the renderer has built the source
+ * object. Concrete `Axis` / `Plane` sources resolve eagerly with no extra
+ * indirection.
+ */
+export declare class LazyMatrix {
+    private _resolver;
+    private _cached;
+    private constructor();
+    resolve(): Matrix4;
+    equals(other: LazyMatrix, tolerance?: number): boolean;
+    static of(matrix: Matrix4): LazyMatrix;
+    static from(resolver: () => Matrix4): LazyMatrix;
+    static mirror(plane: Plane | PlaneLazySource): LazyMatrix;
+    static rotation(axis: Axis | AxisLazySource, angle: number): LazyMatrix;
+    static translation(axis: Axis | AxisLazySource, distance: number): LazyMatrix;
+}

package/lib/dist/math/lazy-matrix.js

@@ -0,0 +1,66 @@
+import { Matrix4 } from "./matrix4.js";
+function isAxisLazySource(a) {
+    return typeof a.getAxis === "function";
+}
+function isPlaneLazySource(p) {
+    return typeof p.getPlane === "function";
+}
+/**
+ * Memoized thunk over a Matrix4. Lets parse-time code thread a transform
+ * value that depends on scene state (e.g. an AxisObjectBase or
+ * PlaneObjectBase) before that state exists. Resolution is deferred to the
+ * first call to `resolve()`, by which point the renderer has built the source
+ * object. Concrete `Axis` / `Plane` sources resolve eagerly with no extra
+ * indirection.
+ */
+export class LazyMatrix {
+    _resolver;
+    _cached;
+    constructor(resolver, cached = null) {
+        this._resolver = resolver;
+        this._cached = cached;
+    }
+    resolve() {
+        if (this._cached === null) {
+            this._cached = this._resolver();
+        }
+        return this._cached;
+    }
+    equals(other, tolerance = 0) {
+        return this.resolve().equals(other.resolve(), tolerance);
+    }
+    static of(matrix) {
+        return new LazyMatrix(() => matrix, matrix);
+    }
+    static from(resolver) {
+        return new LazyMatrix(resolver);
+    }
+    static mirror(plane) {
+        if (isPlaneLazySource(plane)) {
+            return new LazyMatrix(() => {
+                const p = plane.getPlane();
+                return Matrix4.mirrorPlane(p.normal, p.origin);
+            });
+        }
+        return LazyMatrix.of(Matrix4.mirrorPlane(plane.normal, plane.origin));
+    }
+    static rotation(axis, angle) {
+        if (isAxisLazySource(axis)) {
+            return new LazyMatrix(() => {
+                const a = axis.getAxis();
+                return Matrix4.fromRotationAroundAxis(a.origin, a.direction, angle);
+            });
+        }
+        return LazyMatrix.of(Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, angle));
+    }
+    static translation(axis, distance) {
+        if (isAxisLazySource(axis)) {
+            return new LazyMatrix(() => {
+                const dir = axis.getAxis().direction;
+                return Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance);
+            });
+        }
+        const dir = axis.direction;
+        return LazyMatrix.of(Matrix4.fromTranslation(dir.x * distance, dir.y * distance, dir.z * distance));
+    }
+}

package/lib/dist/oc/constraints/constraint-solver-adaptor.d.ts

@@ -17,6 +17,11 @@ export declare class ConstraintSolverAdaptor extends ConstraintSolver {
         edges: Edge[];
         endTangent: Point2D | null;
     };
+    getTangentArcFromPointTangent(plane: Plane, startPoint: Point2D, startTangent: Point2D, target: QualifiedShape, flip: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
     isCurve(shape: Shape): boolean;
+    private isLine;
     private getShapeGeometry;
 }