fluidcad 0.0.36 → 0.0.37

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

@@ -0,0 +1,320 @@
+import { Sketch } from "./sketch.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { FontRegistry } from "../../io/font-registry.js";
+import { TextOutline } from "../../oc/text-outline.js";
+import { PathSampler } from "../../oc/path-sampler.js";
+import { WireOps } from "../../oc/wire-ops.js";
+import { BuildError } from "../../common/build-error.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { Plane } from "../../math/plane.js";
+import { Point } from "../../math/point.js";
+import { Vector3d } from "../../math/vector3d.js";
+const WEIGHT_NAMES = {
+    thin: 100, extralight: 200, ultralight: 200, light: 300, regular: 400,
+    normal: 400, medium: 500, semibold: 600, demibold: 600, bold: 700,
+    extrabold: 800, ultrabold: 800, black: 900, heavy: 900,
+};
+/**
+ * Fits a plane through sampled path points (Newell-style accumulation of
+ * cross products around the centroid). Returns null when the points are
+ * colinear — a straight path carries no orientation of its own.
+ */
+function fitPathPlane(samples, startTangent, pathLength) {
+    const n = samples.length;
+    let cx = 0, cy = 0, cz = 0;
+    for (const p of samples) {
+        cx += p.x;
+        cy += p.y;
+        cz += p.z;
+    }
+    const centroid = new Point(cx / n, cy / n, cz / n);
+    let nx = 0, ny = 0, nz = 0;
+    for (let i = 0; i + 1 < n; i++) {
+        const a = centroid.vectorTo(samples[i]);
+        const b = centroid.vectorTo(samples[i + 1]);
+        const cross = a.cross(b);
+        nx += cross.x;
+        ny += cross.y;
+        nz += cross.z;
+    }
+    const mag = Math.hypot(nx, ny, nz);
+    if (mag < 1e-9 * pathLength * pathLength) {
+        return null;
+    }
+    const normal = new Vector3d(nx / mag, ny / mag, nz / mag);
+    const xDirection = startTangent
+        .subtract(normal.multiply(startTangent.dot(normal)))
+        .normalize();
+    return new Plane(samples[0], xDirection, normal);
+}
+/**
+ * 3D text as an extrudable outline profile. Glyph outlines are produced via
+ * fontkit and converted to sketch edges; extruding the result gives raised or
+ * cut lettering. Works standalone on a plane (`text("xy", "Hi")`), inside a
+ * `sketch()` (`text("Hi")`), or following a planar curve
+ * (`text("Hi", path)`).
+ */
+export class Text extends ExtrudableGeometryBase {
+    text;
+    path;
+    _size = 10;
+    _font;
+    _weight = 400;
+    _italic = false;
+    _align = "left";
+    _lineSpacing = 1;
+    _letterSpacing = 0;
+    _pathOffset = 0;
+    _flip = false;
+    _startAt = 0;
+    _pathPlane = null;
+    constructor(text, targetPlane = null, path = null) {
+        super(targetPlane);
+        this.text = text;
+        this.path = path;
+    }
+    build() {
+        if (this.path) {
+            this.buildAlongPath();
+            return;
+        }
+        if (this._pathOffset !== 0 || this._flip || this._startAt !== 0) {
+            throw new BuildError("text: .offset(), .flip() and .startAt() only apply to text following a path.", "Use the text(string, path) form, or remove these modifiers.");
+        }
+        if (this._align === "space-between" || this._align === "space-around") {
+            throw new BuildError(`text: align('${this._align}') only applies to text following a path.`, "Use the text(string, path) form, or pick left/center/right.");
+        }
+        const plane = this.targetPlane
+            ? this.targetPlane.getPlane()
+            : this.getParent().getPlane();
+        const origin = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const font = FontRegistry.resolve({ font: this._font, weight: this._weight, italic: this._italic });
+        const edges = TextOutline.buildEdges(font, this.text, {
+            size: this._size,
+            align: this._align,
+            lineSpacing: this._lineSpacing,
+            letterSpacing: this._letterSpacing,
+        }, plane, origin);
+        this.addShapes(edges);
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    buildAlongPath() {
+        // Guide curves are included: marking the path `.guide()` is the natural
+        // way to keep it out of the sketch profile while text follows it.
+        const shapes = this.path.getShapes({ excludeMeta: false, excludeGuide: false });
+        const pathEdges = shapes.flatMap(s => s.getSubShapes('edge'));
+        if (pathEdges.length === 0) {
+            throw new BuildError("text: path contains no edges.");
+        }
+        const wire = WireOps.makeWireFromEdges(pathEdges);
+        const sampler = new PathSampler(wire);
+        try {
+            const plane = this.resolvePathPlane(sampler);
+            this._pathPlane = plane;
+            // On a closed loop, normalize the (arbitrary) wire winding so text
+            // sits on the OUTSIDE by default; `.flip()` then moves it inside.
+            // A clockwise loop (w.r.t. the plane normal) already has its glyph
+            // "up" (normal × tangent) pointing outward.
+            let flip = this._flip;
+            if (sampler.closed && !WireOps.isCW(wire, plane.normal)) {
+                flip = !flip;
+            }
+            const font = FontRegistry.resolve({ font: this._font, weight: this._weight, italic: this._italic });
+            const edges = TextOutline.buildEdgesAlongPath(font, this.text, {
+                size: this._size,
+                align: this._align,
+                lineSpacing: this._lineSpacing,
+                letterSpacing: this._letterSpacing,
+            }, {
+                evalAt: (s) => sampler.evalAt(s),
+                length: sampler.length,
+                normal: plane.normal,
+                offset: this._pathOffset,
+                startAt: this._startAt,
+                flip,
+                closed: sampler.closed,
+            });
+            this.addShapes(edges);
+        }
+        finally {
+            sampler.dispose();
+        }
+    }
+    /**
+     * The plane the text lies in: the path object's own plane when it has one
+     * (sketch, planar primitive), otherwise a plane fitted through the path.
+     * Also verifies the path actually is planar.
+     */
+    resolvePathPlane(sampler) {
+        const samples = sampler.sample(64);
+        let plane = this.pathOwnPlane();
+        if (!plane) {
+            plane = fitPathPlane(samples, sampler.evalAt(0).tangent, sampler.length);
+        }
+        if (!plane) {
+            throw new BuildError("text: cannot derive the path's orientation — a straight-line path carries no plane of its own.", "Draw the path in a sketch (or use a planar primitive) so the text knows which way is up.");
+        }
+        const tol = Math.max(1e-5, sampler.length * 1e-6);
+        for (const p of samples) {
+            if (plane.distanceToPoint(p) > tol) {
+                throw new BuildError("text: path must be planar.", "Text can only follow a curve lying in a single plane (e.g. a sketch curve or a planar edge loop).");
+            }
+        }
+        return plane;
+    }
+    pathOwnPlane() {
+        if (this.path instanceof Sketch) {
+            return this.path.getPlane();
+        }
+        if (this.path instanceof ExtrudableGeometryBase) {
+            try {
+                return this.path.getPlane();
+            }
+            catch {
+                return null;
+            }
+        }
+        // Plain sketch geometry (arc, line, …) lies in its sketch's plane.
+        if (this.path instanceof GeometrySceneObject) {
+            const sketch = this.path.sketch;
+            return sketch ? sketch.getPlane() : null;
+        }
+        return null;
+    }
+    getPlane() {
+        if (this.path) {
+            if (!this._pathPlane) {
+                throw new Error("text: the path plane is resolved during build; render the scene first.");
+            }
+            return this._pathPlane;
+        }
+        return super.getPlane();
+    }
+    size(value) {
+        this._size = value;
+        return this;
+    }
+    font(name) {
+        this._font = name;
+        return this;
+    }
+    weight(value) {
+        this._weight = typeof value === "number" ? value : (WEIGHT_NAMES[value.toLowerCase()] ?? 400);
+        return this;
+    }
+    bold() {
+        this._weight = 700;
+        return this;
+    }
+    italic(value = true) {
+        this._italic = value;
+        return this;
+    }
+    align(value) {
+        this._align = value;
+        return this;
+    }
+    lineSpacing(value) {
+        this._lineSpacing = value;
+        return this;
+    }
+    letterSpacing(value) {
+        this._letterSpacing = value;
+        return this;
+    }
+    offset(value) {
+        this._pathOffset = value;
+        return this;
+    }
+    flip(value = true) {
+        this._flip = value;
+        return this;
+    }
+    startAt(distance) {
+        this._startAt = distance;
+        return this;
+    }
+    getType() {
+        return "text";
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.path) {
+            deps.push(this.path);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane
+            ? (remap.get(this.targetPlane) || this.targetPlane)
+            : null;
+        const path = this.path
+            ? (remap.get(this.path) || this.path)
+            : null;
+        const copy = new Text(this.text, targetPlane, path);
+        copy._size = this._size;
+        copy._font = this._font;
+        copy._weight = this._weight;
+        copy._italic = this._italic;
+        copy._align = this._align;
+        copy._lineSpacing = this._lineSpacing;
+        copy._letterSpacing = this._letterSpacing;
+        copy._pathOffset = this._pathOffset;
+        copy._flip = this._flip;
+        copy._startAt = this._startAt;
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Text)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        if (this.path?.constructor !== other.path?.constructor) {
+            return false;
+        }
+        if (this.path && other.path && !this.path.compareTo(other.path)) {
+            return false;
+        }
+        return this.text === other.text
+            && this._size === other._size
+            && this._font === other._font
+            && this._weight === other._weight
+            && this._italic === other._italic
+            && this._align === other._align
+            && this._lineSpacing === other._lineSpacing
+            && this._letterSpacing === other._letterSpacing
+            && this._pathOffset === other._pathOffset
+            && this._flip === other._flip
+            && this._startAt === other._startAt;
+    }
+    serialize() {
+        return {
+            text: this.text,
+            size: this._size,
+            font: this._font,
+            weight: this._weight,
+            italic: this._italic,
+            align: this._align,
+            lineSpacing: this._lineSpacing,
+            letterSpacing: this._letterSpacing,
+            offset: this._pathOffset,
+            flip: this._flip,
+            startAt: this._startAt,
+        };
+    }
+}

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

@@ -1,9 +1,11 @@
 import { TransformablePrimitive } from "../common/transformable-primitive.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 export declare class Cylinder extends TransformablePrimitive {
     radius: number;
     height: number;
     constructor(radius: number, height: number);
-    build(): void;
+    build(context?: BuildSceneObjectContext): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Cylinder): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/cylinder.js

@@ -8,9 +8,12 @@ export class Cylinder extends TransformablePrimitive {
         this.radius = radius;
         this.height = height;
     }
-    build() {
+    build(context) {
         const cyl = Primitives.makeCylinder(this.radius, this.height);
-        this.addShapes([cyl]);
+        this.addPrimitiveShape(cyl, context);
+    }
+    createCopy(remap) {
+        return new Cylinder(this.radius, this.height).syncPrimitiveWith(this);
     }
     compareTo(other) {
         if (!(other instanceof Cylinder)) {

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

@@ -87,6 +87,7 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
      */
     protected finalizeAndFuse(shapes: Shape[], classified: ClassifiedFaces, context: BuildSceneObjectContext, fuseOpts?: {
         glue?: 'full' | 'shift';
+        skipSimplify?: boolean;
     }): void;
     /**
      * One-shot edge classification: derive start/end/side/internal/cap edges

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

@@ -11,6 +11,7 @@ export declare class ExtrudeToFace extends ExtrudeBase {
     private createAdvancedExtrude;
     private resizePlanarFace;
     private resizeCylindricalFace;
+    private resizeConicalFace;
     /**
      * Computes the signed distance from the sketch plane to the farthest
      * bounding-box corner of the target face, measured along the sketch

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

@@ -139,6 +139,9 @@ export class ExtrudeToFace extends ExtrudeBase {
             if (surfaceType === 'cylinder') {
                 splitTargetFace = this.resizeCylindricalFace(targetFace);
             }
+            else if (surfaceType === 'cone') {
+                splitTargetFace = this.resizeConicalFace(targetFace);
+            }
             else {
                 splitTargetFace = targetFace;
             }
@@ -157,6 +160,9 @@ export class ExtrudeToFace extends ExtrudeBase {
     resizeCylindricalFace(targetFace) {
         return FaceQuery.makeInfiniteCylindricalFace(targetFace, this.getEndOffset());
     }
+    resizeConicalFace(targetFace) {
+        return FaceQuery.makeInfiniteConicalFace(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

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

@@ -8,7 +8,7 @@ export declare class Fillet extends SceneObject {
     validate(): void;
     build(context: BuildSceneObjectContext): void;
     doBuild(sceneObjectsMap: Map<SceneObject, Shape[]>, selections: SceneObject[]): {
-        addedShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
+        addedShapes: Shape<import("ocjs-fluidcad").TopoDS_Shape>[];
         removedShapes: {
             shape: Shape;
             owner: SceneObject;

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

@@ -0,0 +1,41 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { IHelix } from "../core/interfaces.js";
+export declare class Helix extends SceneObject implements IHelix {
+    source: AxisObjectBase | SceneObject;
+    private _pitch?;
+    private _turns?;
+    private _startOffset;
+    private _endOffset;
+    private _height?;
+    private _radius?;
+    private _endRadius?;
+    constructor(source: AxisObjectBase | SceneObject);
+    pitch(value: number): this;
+    turns(value: number): this;
+    startOffset(value: number): this;
+    endOffset(value: number): this;
+    height(value: number): this;
+    radius(value: number): this;
+    endRadius(value: number): this;
+    validate(): void;
+    build(_context?: BuildSceneObjectContext): void;
+    private deriveTurnsFromHeight;
+    private resolveSource;
+    private resolveFace;
+    private resolveEdge;
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SceneObject): boolean;
+    serialize(): {
+        source: any;
+        pitch: number;
+        turns: number;
+        startOffset: number;
+        endOffset: number;
+        height: number;
+        radius: number;
+        endRadius: number;
+    };
+}