fluidcad 0.0.36 → 0.0.37

package/lib/dist/common/transformable-primitive.js

@@ -3,12 +3,39 @@ import { Matrix4 } from "../math/matrix4.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
 import { isNumberParam, resolveParam } from "../core/param.js";
 export class TransformablePrimitive extends SceneObject {
     transform(matrix) {
         this.composeAppliedTransform(matrix);
         return this;
     }
+    /**
+     * Adds a primitive's built shape, baking in the clone transform when this
+     * primitive is a repeat/mirror copy. The renderer post-applies the user's
+     * own transform (translate/rotate/mirror) after build, so the clone
+     * transform is conjugated to land outside it:
+     * own · (own⁻¹ · clone · own) = clone · own.
+     */
+    addPrimitiveShape(shape, context) {
+        const cloneTransform = context?.getTransform() ?? null;
+        if (cloneTransform) {
+            const own = this.getAppliedTransform();
+            const matrix = own
+                ? own.inverse().multiply(cloneTransform).multiply(own)
+                : cloneTransform;
+            shape = ShapeOps.transform(shape, matrix);
+        }
+        this.addShape(shape);
+    }
+    /** Carries the user's own transform onto a repeat/mirror copy. */
+    syncPrimitiveWith(source) {
+        const applied = source.getAppliedTransform();
+        if (applied) {
+            this.transform(applied);
+        }
+        return this;
+    }
     translate(a, b, c) {
         let x, y, z;
         if (isNumberParam(a)) {

package/lib/dist/common/vertex.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Vertex } from "occjs-wrapper";
+import type { TopoDS_Vertex } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Point, Point2D } from "../math/point.js";

package/lib/dist/common/wire.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Wire } from "occjs-wrapper";
+import type { TopoDS_Wire } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Vector3d } from "../math/vector3d.js";

package/lib/dist/core/2d/index.d.ts

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

package/lib/dist/core/2d/index.js

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

package/lib/dist/core/2d/text.d.ts

@@ -0,0 +1,30 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IText, ISceneObject } from "../interfaces.js";
+interface TextFunction {
+    /**
+     * Renders a text string as extrudable outline geometry inside the current
+     * sketch, at the sketch cursor.
+     * @param text - The string to render.
+     */
+    (text: string): IText;
+    /**
+     * Renders a text string on a specific plane (standalone, outside a sketch).
+     * @param plane - The plane (e.g. "xy") or face to render the text on.
+     * @param text - The string to render.
+     */
+    (plane: PlaneLike | ISceneObject, text: string): IText;
+    /**
+     * Renders a text string following a planar curve. Each glyph is placed
+     * upright along the path's arc length; the text plane is the path's plane.
+     * Works inside a sketch (following a curve of that sketch) or standalone.
+     * The path is left in place — mark it `.guide()` to keep it out of
+     * extruded profiles.
+     * @param text - The string to render.
+     * @param path - The curve to follow: a sketch curve (line/arc/circle), a
+     *   whole sketch, a planar primitive, or a selected edge/edge loop
+     *   (e.g. `select(edge().circle())`).
+     */
+    (text: string, path: ISceneObject): IText;
+}
+declare const _default: TextFunction;
+export default _default;

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

@@ -0,0 +1,37 @@
+import { Text } from "../../features/2d/text.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function text() {
+        const first = arguments[0];
+        const second = arguments[1];
+        // A trailing scene object is a path to follow: `text("Hi", path)`.
+        // Valid both standalone and inside a sketch (following a sketch curve).
+        if (arguments.length >= 2 && second instanceof SceneObject) {
+            if (typeof first !== "string") {
+                throw new Error("text: when following a path, the first argument must be the text string.");
+            }
+            const obj = new Text(first, null, second);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        // A leading plane/face is only valid standalone and only when a string
+        // follows it; `text("xy")` (one arg) renders the literal string "xy".
+        const standalone = arguments.length >= 2 && (isPlaneLike(first) || first instanceof SceneObject);
+        if (standalone) {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("text(plane, ...) cannot be used inside a sketch. Use text(...) instead.");
+            }
+            const planeObj = resolvePlane(first, context);
+            const obj = new Text(String(arguments[1] ?? ""), planeObj);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        const obj = new Text(String(first ?? ""));
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,20 @@
+import { AxisLike } from "../math/axis.js";
+import { IHelix, ISceneObject } from "./interfaces.js";
+interface HelixFunction {
+    /**
+     * Creates a helix wire along the given axis. Use chained methods (.pitch(),
+     * .turns(), .height(), .radius(), .endRadius()) to configure geometry.
+     * @param axis - The axis to build the helix around.
+     */
+    (axis: AxisLike): IHelix;
+    /**
+     * Creates a helix wire derived from a scene object's geometry.
+     * - A cylindrical or conical face: axis + radii + height come from the face.
+     * - A line edge: axis = the line, height = line length.
+     * - A circular edge: axis = circle normal at center, radius = circle radius.
+     * @param source - The scene object whose face/edge defines the helix.
+     */
+    (source: ISceneObject): IHelix;
+}
+declare const _default: HelixFunction;
+export default _default;

package/lib/dist/core/helix.js

@@ -0,0 +1,36 @@
+import { registerBuilder } from "../index.js";
+import { Helix } from "../features/helix.js";
+import { isAxisLike } from "../math/axis.js";
+import { AxisObject } from "../features/axis.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { normalizeAxis } from "../helpers/normalize.js";
+function build(context) {
+    return function helix() {
+        if (arguments.length === 0) {
+            throw new Error("helix() requires an axis or scene object argument.");
+        }
+        const arg = arguments[0];
+        let source;
+        if (arg instanceof AxisObjectBase) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else if (isAxisLike(arg)) {
+            const axis = normalizeAxis(arg);
+            source = new AxisObject(axis);
+            context.addSceneObject(source);
+        }
+        else if (arg instanceof SceneObject) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else {
+            throw new Error("helix(): first argument must be an AxisLike or SceneObject.");
+        }
+        const result = new Helix(source);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IText, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib, IHelix, IWrap } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
@@ -24,6 +24,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/index.js

@@ -23,6 +23,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/interfaces.d.ts

@@ -144,6 +144,82 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IText extends IExtrudableGeometry {
+    /**
+     * Sets the text height (em size) in model units. Default 10.
+     * @param value - The em size.
+     */
+    size(value: number): this;
+    /**
+     * Sets the font. A name without a font extension (e.g. `"Arial"`) is resolved
+     * to a system font; a value ending in `.ttf`/`.otf`/`.ttc`/`.woff` (e.g.
+     * `"fonts/Brand.ttf"`) is loaded as a workspace-relative file. When omitted, a
+     * default system font is used.
+     * @param name - A system family name or a workspace-relative font file path.
+     */
+    font(name: string): this;
+    /**
+     * Sets the font weight: a number (100–900) or a name such as `"regular"`,
+     * `"medium"`, or `"bold"`. Resolves to the matching face (or the wght axis of a
+     * variable font).
+     * @param value - The weight as a number or name.
+     */
+    weight(value: number | string): this;
+    /**
+     * Shortcut for `weight(700)`.
+     */
+    bold(): this;
+    /**
+     * Renders the italic/oblique face of the font.
+     * @param value - Whether to use italic (defaults to true).
+     */
+    italic(value?: boolean): this;
+    /**
+     * Horizontal alignment of the text. For straight text it is relative to the
+     * origin point; for text along a path it positions the run against the
+     * path: `"start"` begins at the path's start, `"center"` centers on the
+     * midpoint, `"end"` finishes at the path's end, `"space-between"` justifies
+     * the glyphs evenly across the whole path, and `"space-around"` spreads
+     * them with half a gap before the first glyph and after the last, like the
+     * CSS flexbox value (both path text only). `"left"` and `"right"` are
+     * synonyms of `"start"` and `"end"`.
+     * @param value - `"left"`/`"start"` (default), `"center"`,
+     *   `"right"`/`"end"`, `"space-between"`, or `"space-around"`.
+     */
+    align(value: "left" | "center" | "right" | "start" | "end" | "space-between" | "space-around"): this;
+    /**
+     * Line-height multiplier for multi-line text (newlines in the string).
+     * @param value - Multiplier on the font's natural line height (default 1).
+     */
+    lineSpacing(value: number): this;
+    /**
+     * Extra spacing added between glyphs, in model units (default 0).
+     * @param value - The additional advance per glyph.
+     */
+    letterSpacing(value: number): this;
+    /**
+     * Shifts the baseline perpendicular to the path, in model units: positive
+     * values move the text toward its "up" side, negative below the path.
+     * Only applies to text following a path (`text(string, path)`).
+     * @param value - The perpendicular baseline shift.
+     */
+    offset(value: number): this;
+    /**
+     * Mirrors the text to the other side of the path, reversing the reading
+     * direction. On a closed path (circle, loop) text sits on the outside by
+     * default — `.flip()` moves it inside. On an open path it mirrors the text
+     * below the curve. Only applies to text following a path.
+     * @param value - Whether to flip (defaults to true).
+     */
+    flip(value?: boolean): this;
+    /**
+     * Shifts where the text starts along the path, as an arc-length distance
+     * from the path's start (combines with `align()`). On a closed path the
+     * text wraps around. Only applies to text following a path.
+     * @param distance - The arc-length shift in model units.
+     */
+    startAt(distance: number): this;
+}
 export interface IOffset extends IExtrudableGeometry {
     /**
      * Closes an open offset by joining it back to the source wire with
@@ -794,6 +870,59 @@ export interface IRib extends IBooleanOperation {
      */
     extend(): this;
 }
+export interface IWrap extends IBooleanOperation {
+    /**
+     * Selects the faces lying on the target surface (the base of the wrap).
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    startFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the raised (or recessed) faces offset from the target surface by the wrap thickness.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    endFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the base faces of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    startEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the offset faces of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    endEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the wall faces created from the outer boundary of each wrapped region.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    sideFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the wall faces, excluding edges shared with base/offset faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    sideEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the wall faces created from holes inside a wrapped region.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    internalFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges bounding the hole walls of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Enables or disables drill mode, which partitions the sketch into face regions
+     * before wrapping.
+     * @param value - `true` to enable (default), `false` to disable.
+     */
+    drill(value?: boolean): this;
+    /**
+     * Restricts wrapping to only the sketch regions containing the given points.
+     * @param points - 2D points in the sketch plane identifying regions to wrap.
+     */
+    pick(...points: Point2DLike[]): this;
+}
 export type ShellJoinType = 'arc' | 'intersection' | 'tangent';
 export interface IShell extends ISceneObject {
     /**
@@ -814,3 +943,54 @@ export interface IShell extends ISceneObject {
      */
     join(type: ShellJoinType): this;
 }
+/**
+ * A 3D helix wire — a single edge that traces a helix curve on a cylindrical or
+ * conical surface. Used as a path for `sweep()` to produce springs, threads, and
+ * coils.
+ *
+ * Created from one of:
+ * - An axis (`AxisLike`): user supplies geometry via chained config.
+ * - A cylindrical or conical face: axis + radii + height derived from the face.
+ * - A line edge: axis = the line, height = line length.
+ * - A circular edge: axis = circle normal, radius = circle radius.
+ */
+export interface IHelix extends ISceneObject {
+    /**
+     * Axial rise per turn (distance along the helix axis covered per full revolution).
+     * If unset, derived from `height / turns`.
+     */
+    pitch(pitch: number): this;
+    /**
+     * Number of full turns. Fractional values are allowed. Default 1.
+     */
+    turns(turns: number): this;
+    /**
+     * Shifts the start of the helix along its axis, in axial mm. Positive values
+     * trim the start (move it toward the end); negative values extend it. Default 0.
+     */
+    startOffset(offset: number): this;
+    /**
+     * Extends (positive) or trims (negative) the helix at its end, in axial mm.
+     * Default 0.
+     */
+    endOffset(offset: number): this;
+    /**
+     * Total axial height. Overrides face/edge-derived height when set. For line-edge
+     * input, defaults to the line length. For circular-edge / pure-axis input,
+     * defaults to 50 if neither this nor `pitch * turns` determine it.
+     */
+    height(height: number): this;
+    /**
+     * Start radius. Defaults to 20 for axis/line-edge input. For a cylindrical
+     * face input, defaults to the face's radius and may be overridden (useful for
+     * sweep/fuse workflows where the helix tube must overlap the cylinder
+     * volumetrically — offset by ~1mm to avoid pure tangency). Ignored on
+     * conical face input (radius is derived from face geometry).
+     */
+    radius(radius: number): this;
+    /**
+     * End radius — when different from `radius()`, produces a conical helix.
+     * Defaults to `radius()`. Ignored on face/circle inputs.
+     */
+    endRadius(radius: number): this;
+}

package/lib/dist/core/wrap.d.ts

@@ -0,0 +1,17 @@
+import { IWrap, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
+interface WrapFunction {
+    /**
+     * Wraps the given sketch onto a curved face, raising it from the surface by
+     * the given thickness (emboss). Chain `.remove()` to sink it into the
+     * surface instead (deboss), or `.new()` to keep the wrapped pad standalone.
+     * The sketch is developed onto the surface with its lengths preserved — a
+     * true wrap, not a projection. Cylindrical and conical faces are supported.
+     * @param thickness - Pad thickness measured along the surface normal (must be positive)
+     * @param sketch - The sketch to wrap onto the face
+     * @param face - The target face to wrap onto
+     */
+    (thickness: NumberParam, sketch: ISceneObject, face: ISceneObject): IWrap;
+}
+declare const _default: WrapFunction;
+export default _default;

package/lib/dist/core/wrap.js

@@ -0,0 +1,39 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Wrap } from "../features/wrap.js";
+import { isNumberParam, resolveParam } from "./param.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    //@ts-ignore
+    return function wrap() {
+        const args = [...arguments];
+        if (args.length !== 3) {
+            throw new Error("wrap() expects (thickness, sketch, face).");
+        }
+        if (!isNumberParam(args[0])) {
+            throw new Error("wrap() thickness must be a positive number.");
+        }
+        const thickness = resolveParam(args[0]);
+        if (!(thickness > 0)) {
+            throw new Error("wrap() thickness must be a positive number.");
+        }
+        const source = args[1];
+        if (!(source instanceof SceneObject)) {
+            throw new Error("wrap() sketch must be a sketch or face-bearing scene object.");
+        }
+        const face = args[2];
+        if (!(face instanceof SceneObject) || isExtrudable(face)) {
+            throw new Error("wrap() requires a target face selection as its last argument.");
+        }
+        if (!isExtrudable(source)) {
+            context.addSceneObject(source);
+        }
+        context.addSceneObject(face);
+        const result = new Wrap(thickness, face, source);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -0,0 +1,67 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { IText } from "../../core/interfaces.js";
+import { type TextAlign } from "../../oc/text-outline.js";
+import { Plane } from "../../math/plane.js";
+/**
+ * 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 declare class Text extends ExtrudableGeometryBase implements IText {
+    text: string;
+    private path;
+    private _size;
+    private _font?;
+    private _weight;
+    private _italic;
+    private _align;
+    private _lineSpacing;
+    private _letterSpacing;
+    private _pathOffset;
+    private _flip;
+    private _startAt;
+    private _pathPlane;
+    constructor(text: string, targetPlane?: PlaneObjectBase, path?: SceneObject);
+    build(): void;
+    private buildAlongPath;
+    /**
+     * 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.
+     */
+    private resolvePathPlane;
+    private pathOwnPlane;
+    getPlane(): Plane;
+    size(value: number): this;
+    font(name: string): this;
+    weight(value: number | string): this;
+    bold(): this;
+    italic(value?: boolean): this;
+    align(value: TextAlign): this;
+    lineSpacing(value: number): this;
+    letterSpacing(value: number): this;
+    offset(value: number): this;
+    flip(value?: boolean): this;
+    startAt(distance: number): this;
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Text): boolean;
+    serialize(): {
+        text: string;
+        size: number;
+        font: string;
+        weight: number;
+        italic: boolean;
+        align: TextAlign;
+        lineSpacing: number;
+        letterSpacing: number;
+        offset: number;
+        flip: boolean;
+        startAt: number;
+    };
+}