fluidcad 0.0.34 → 0.0.35

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

@@ -5,6 +5,7 @@ import type { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import type { Matrix4 } from "../math/matrix4.js";
 import type { AxisLike } from "../math/axis.js";
 import type { PlaneLike } from "../math/plane.js";
+import type { NumberParam } from "./param.js";
 export interface ISceneObject {
     /**
      * Sets a custom display name for this object, overriding the default type-based name.
@@ -81,15 +82,15 @@ export interface ITransformable extends ISceneObject {
      * Translate along X.
      * @param x - Distance along world X.
      */
-    translate(x: number): this;
+    translate(x: NumberParam): this;
     /**
      * Translate along X and Y.
      */
-    translate(x: number, y: number): this;
+    translate(x: NumberParam, y: NumberParam): this;
     /**
      * Translate along X, Y, and Z.
      */
-    translate(x: number, y: number, z: number): this;
+    translate(x: NumberParam, y: NumberParam, z: NumberParam): this;
     /**
      * Translate by a point-like offset in world space.
      */
@@ -98,13 +99,13 @@ export interface ITransformable extends ISceneObject {
      * Rotate by an angle around world Z through the origin.
      * @param angle - Rotation in degrees.
      */
-    rotate(angle: number): this;
+    rotate(angle: NumberParam): this;
     /**
      * Rotate around an axis by an angle.
      * @param axis - The axis to rotate around. Use `local(...)` to reference a sketch-local axis.
      * @param angle - Rotation in degrees.
      */
-    rotate(axis: AxisLike, angle: number): this;
+    rotate(axis: AxisLike, angle: NumberParam): this;
     /**
      * Mirror across a plane.
      */
@@ -157,7 +158,7 @@ export interface IArcPoints extends IExtrudableGeometry {
      * Positive = CCW, negative = CW.
      * @param value - The bulge radius.
      */
-    radius(value: number): IArcRadius;
+    radius(value: NumberParam): IArcRadius;
     /**
      * Specifies the circle center point for the arc.
      * Mutually exclusive with `.radius()`.
@@ -259,7 +260,7 @@ export interface ISlot extends IExtrudableGeometry {
      * Sets the rotation angle of the slot's primary axis.
      * @param angle - Rotation in degrees.
      */
-    rotate(angle: number): this;
+    rotate(angle: NumberParam): this;
 }
 export interface IALine extends IGeometry {
     /**
@@ -400,12 +401,12 @@ export interface IExtrude extends IBooleanOperation {
      * Applies a draft (taper) angle to the extrusion walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
      */
-    draft(value: number | [number, number]): this;
+    draft(value: NumberParam | [NumberParam, NumberParam]): this;
     /**
      * Offsets the end face by a specified distance along the extrusion direction.
      * @param value - The offset distance.
      */
-    endOffset(value: number): this;
+    endOffset(value: NumberParam): this;
     /**
      * Enables or disables drill mode, which partitions the sketch into face regions
      * before extruding.
@@ -422,7 +423,7 @@ export interface IExtrude extends IBooleanOperation {
      * instead of extruding filled faces. Positive values offset outward, negative values offset inward.
      * @param offset - The wall offset distance. Positive = outward, negative = inward.
      */
-    thin(offset: number): this;
+    thin(offset: NumberParam): this;
     /**
      * Enables thin extrude mode with two offset directions.
      * The two offsets must go in opposite directions. If both have the same sign,
@@ -430,7 +431,7 @@ export interface IExtrude extends IBooleanOperation {
      * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
      * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
      */
-    thin(offset1: number, offset2: number): this;
+    thin(offset1: NumberParam, offset2: NumberParam): this;
 }
 export interface ICut extends ISceneObject {
     /**
@@ -447,12 +448,12 @@ export interface ICut extends ISceneObject {
      * Applies a draft (taper) angle to the cut walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
      */
-    draft(value: number | [number, number]): this;
+    draft(value: NumberParam | [NumberParam, NumberParam]): this;
     /**
      * Offsets the cut end face by a specified distance along the cut direction.
      * @param value - The offset distance.
      */
-    endOffset(value: number): this;
+    endOffset(value: NumberParam): this;
     /**
      * Selects edges at the start of the cut path, classified by signed distance from the cut plane.
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
@@ -483,7 +484,7 @@ export interface ICut extends ISceneObject {
      * instead of cutting filled faces. Positive values offset outward, negative values offset inward.
      * @param offset - The wall offset distance. Positive = outward, negative = inward.
      */
-    thin(offset: number): this;
+    thin(offset: NumberParam): this;
     /**
      * Enables thin cut mode with two offset directions.
      * The two offsets must go in opposite directions. If both have the same sign,
@@ -491,7 +492,7 @@ export interface ICut extends ISceneObject {
      * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
      * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
      */
-    thin(offset1: number, offset2: number): this;
+    thin(offset1: NumberParam, offset2: NumberParam): this;
 }
 export interface IRevolve extends IBooleanOperation {
     /**
@@ -509,7 +510,7 @@ export interface IRevolve extends IBooleanOperation {
      * outward, negative values offset inward.
      * @param offset - The wall offset distance. Positive = outward, negative = inward.
      */
-    thin(offset: number): this;
+    thin(offset: NumberParam): this;
     /**
      * Enables thin revolve mode with two offset directions.
      * The two offsets must go in opposite directions. If both have the same sign,
@@ -517,7 +518,7 @@ export interface IRevolve extends IBooleanOperation {
      * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
      * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
      */
-    thin(offset1: number, offset2: number): this;
+    thin(offset1: NumberParam, offset2: NumberParam): this;
     /**
      * Selects faces created inside the solid during revolution (e.g., the inner
      * wall of a thin-walled revolve from a closed profile).
@@ -578,7 +579,7 @@ export interface ILoft extends IBooleanOperation {
      * and share the same topology. Positive values offset outward, negative offsets inward.
      * @param offset - The wall offset distance. Positive = outward, negative = inward.
      */
-    thin(offset: number): this;
+    thin(offset: NumberParam): this;
     /**
      * Enables thin loft mode with two offset directions.
      * The two offsets must go in opposite directions. If both have the same sign,
@@ -586,7 +587,7 @@ export interface ILoft extends IBooleanOperation {
      * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
      * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
      */
-    thin(offset1: number, offset2: number): this;
+    thin(offset1: NumberParam, offset2: NumberParam): this;
     /**
      * Selects faces created inside the solid during loft (e.g., the inner
      * wall of a thin-walled loft from closed profiles).
@@ -655,12 +656,12 @@ export interface ISweep extends IBooleanOperation {
      * Applies a draft (taper) angle to the sweep walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
      */
-    draft(value: number | [number, number]): this;
+    draft(value: NumberParam | [NumberParam, NumberParam]): this;
     /**
      * Offsets the end face by a specified distance along the sweep direction.
      * @param value - The offset distance.
      */
-    endOffset(value: number): this;
+    endOffset(value: NumberParam): this;
     /**
      * Enables or disables drill mode.
      * @param value - `true` to enable (default), `false` to disable.
@@ -677,7 +678,7 @@ export interface ISweep extends IBooleanOperation {
      * negative values offset inward.
      * @param offset - The wall offset distance. Positive = outward, negative = inward.
      */
-    thin(offset: number): this;
+    thin(offset: NumberParam): this;
     /**
      * Enables thin sweep mode with two offset directions.
      * The two offsets must go in opposite directions. If both have the same sign,
@@ -685,7 +686,7 @@ export interface ISweep extends IBooleanOperation {
      * @param offset1 - The first wall offset distance. Positive = outward, negative = inward.
      * @param offset2 - The second wall offset distance, in the opposite direction of offset1.
      */
-    thin(offset1: number, offset2: number): this;
+    thin(offset1: NumberParam, offset2: NumberParam): this;
     /**
      * Selects the cap faces at the open ends of a thin-walled sweep from an open profile.
      * These are the small faces connecting the inner and outer walls at the profile endpoints.
@@ -781,7 +782,7 @@ export interface IRib extends IBooleanOperation {
      * Applies a draft (taper) angle to the rib walls.
      * @param value - A single angle for uniform draft, or a `[start, end]` tuple for asymmetric draft.
      */
-    draft(value: number | [number, number]): this;
+    draft(value: NumberParam | [NumberParam, NumberParam]): this;
     /**
      * Switches the extrusion direction to parallel to the sketch plane
      * (perpendicular to the spine within the plane) instead of normal to it.

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

@@ -0,0 +1,74 @@
+import { type MultiControlType, type SelectOption } from "../param-registry.js";
+export type ParamType = 'number' | 'slider' | 'text' | 'select' | 'checkbox' | 'color';
+interface BaseParamOptions {
+    group?: string;
+    description?: string;
+}
+export interface NumberParamOptions extends BaseParamOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export interface SliderParamOptions extends BaseParamOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export interface SelectParamOptions extends BaseParamOptions {
+    options: SelectOption[];
+    multi?: boolean;
+    multiControlType?: MultiControlType;
+}
+export type CheckboxParamOptions = BaseParamOptions;
+export type TextParamOptions = BaseParamOptions;
+export type ColorParamOptions = BaseParamOptions;
+export interface ParamOptionsMap {
+    number: NumberParamOptions;
+    slider: SliderParamOptions;
+    select: SelectParamOptions;
+    checkbox: CheckboxParamOptions;
+    text: TextParamOptions;
+    color: ColorParamOptions;
+}
+/** @deprecated Use `param()` with a `ParamOptions` object instead. */
+export declare class ParamValue<T extends string | number | boolean> {
+    private _value;
+    private _definition;
+    constructor(label: string, defaultValue: T);
+    slider(opts?: {
+        min?: number;
+        max?: number;
+        step?: number;
+    }): this;
+    number(opts?: {
+        min?: number;
+        max?: number;
+        step?: number;
+    }): this;
+    text(): this;
+    checkbox(): this;
+    select(items: SelectOption[], opts?: {
+        multi?: boolean;
+        multiControlType?: MultiControlType;
+    }): this;
+    description(desc: string): this;
+    group(name: string): this;
+    valueOf(): T;
+    toString(): string;
+    toJSON(): T;
+    [Symbol.toPrimitive](hint: string): T | string;
+}
+export type NumberParam = number | ParamValue<number>;
+export type StringParam = string | ParamValue<string>;
+export type BooleanParam = boolean | ParamValue<boolean>;
+export declare function isNumberParam(v: unknown): v is NumberParam;
+export declare function isBooleanParam(v: unknown): v is BooleanParam;
+export declare function resolveParam(v: NumberParam): number;
+export declare function resolveParam(v: StringParam): string;
+export declare function resolveParam(v: BooleanParam): boolean;
+export default function param<T extends string | number | boolean>(label: string, defaultValue: T): T;
+export default function param<T extends string | number | boolean, K extends ParamType>(label: string, defaultValue: T, type: K, options?: ParamOptionsMap[K]): T;
+export default function param(label: string, defaultValue: (string | number)[], type: 'select', options: SelectParamOptions & {
+    multi: true;
+}): (string | number)[];
+export {};

package/lib/dist/core/param.js

@@ -0,0 +1,147 @@
+import { getParamRegistry } from "../param-registry.js";
+/** @deprecated Use `param()` with a `ParamOptions` object instead. */
+export class ParamValue {
+    _value;
+    _definition;
+    constructor(label, defaultValue) {
+        const registry = getParamRegistry();
+        this._value = registry.resolve(label, defaultValue);
+        this._definition = {
+            label,
+            defaultValue,
+            currentValue: this._value,
+            controlType: typeof defaultValue === 'boolean' ? 'checkbox'
+                : typeof defaultValue === 'number' ? 'number'
+                    : 'text',
+        };
+        registry.register(this._definition);
+    }
+    slider(opts) {
+        this._definition.controlType = 'slider';
+        if (opts) {
+            if (opts.min != null) {
+                this._definition.min = opts.min;
+            }
+            if (opts.max != null) {
+                this._definition.max = opts.max;
+            }
+            if (opts.step != null) {
+                this._definition.step = opts.step;
+            }
+        }
+        return this;
+    }
+    number(opts) {
+        this._definition.controlType = 'number';
+        if (opts) {
+            if (opts.min != null) {
+                this._definition.min = opts.min;
+            }
+            if (opts.max != null) {
+                this._definition.max = opts.max;
+            }
+            if (opts.step != null) {
+                this._definition.step = opts.step;
+            }
+        }
+        return this;
+    }
+    text() {
+        this._definition.controlType = 'text';
+        return this;
+    }
+    checkbox() {
+        this._definition.controlType = 'checkbox';
+        return this;
+    }
+    select(items, opts) {
+        this._definition.controlType = 'select';
+        this._definition.options = items;
+        if (opts?.multi) {
+            this._definition.multi = true;
+        }
+        if (opts?.multiControlType) {
+            this._definition.multiControlType = opts.multiControlType;
+        }
+        return this;
+    }
+    description(desc) {
+        this._definition.description = desc;
+        return this;
+    }
+    group(name) {
+        this._definition.group = name;
+        return this;
+    }
+    valueOf() {
+        return this._value;
+    }
+    toString() {
+        return String(this._value);
+    }
+    toJSON() {
+        return this._value;
+    }
+    [Symbol.toPrimitive](hint) {
+        if (hint === 'string') {
+            return String(this._value);
+        }
+        return this._value;
+    }
+}
+export function isNumberParam(v) {
+    return typeof v === 'number' || (v instanceof ParamValue && typeof v.valueOf() === 'number');
+}
+export function isBooleanParam(v) {
+    return typeof v === 'boolean' || (v instanceof ParamValue && typeof v.valueOf() === 'boolean');
+}
+export function resolveParam(v) {
+    if (v instanceof ParamValue) {
+        return v.valueOf();
+    }
+    return v;
+}
+export default function param(label, defaultValue, type, options) {
+    const registry = getParamRegistry();
+    const value = Array.isArray(defaultValue)
+        ? registry.resolve(label, defaultValue)
+        : registry.resolve(label, defaultValue);
+    const controlType = type
+        ?? (typeof defaultValue === 'boolean' ? 'checkbox'
+            : typeof defaultValue === 'number' ? 'number'
+                : 'text');
+    const definition = {
+        label,
+        defaultValue,
+        currentValue: value,
+        controlType,
+    };
+    if (options) {
+        if ('group' in options && options.group != null) {
+            definition.group = options.group;
+        }
+        if ('description' in options && options.description != null) {
+            definition.description = options.description;
+        }
+        if ('min' in options && options.min != null) {
+            definition.min = options.min;
+        }
+        if ('max' in options && options.max != null) {
+            definition.max = options.max;
+        }
+        if ('step' in options && options.step != null) {
+            definition.step = options.step;
+        }
+        if ('options' in options && options.options != null) {
+            definition.options = options.options;
+        }
+        if ('multi' in options && options.multi != null) {
+            definition.multi = options.multi;
+        }
+        if ('multiControlType' in options && options.multiControlType != null) {
+            definition.multiControlType = options.multiControlType;
+        }
+    }
+    registry.register(definition);
+    return value;
+}

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

@@ -3,6 +3,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { LinearRepeatOptions } from "../features/repeat-linear.js";
 import { CircularRepeatOptions } from "../features/repeat-circular.js";
 import { ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 import { PlaneLike } from "../math/plane.js";
 export type RepeatType = 'linear' | 'circular' | 'mirror' | 'rotate';
 interface RepeatFunction {
@@ -44,7 +45,7 @@ interface RepeatFunction {
      * @param angle - The rotation angle in degrees (defaults to 90)
      * @param objects - The objects to rotate (defaults to last object)
      */
-    (type: 'rotate', axis: AxisLike, angle?: number, ...objects: ISceneObject[]): ISceneObject;
+    (type: 'rotate', axis: AxisLike, angle?: NumberParam, ...objects: ISceneObject[]): ISceneObject;
     /**
      * Creates a transformed clone of objects using an arbitrary matrix.
      * @param matrix - The transformation matrix to apply

package/lib/dist/core/repeat.js

@@ -7,6 +7,7 @@ import { rad } from "../helpers/math-helpers.js";
 import { RepeatLinear } from "../features/repeat-linear.js";
 import { RepeatCircular } from "../features/repeat-circular.js";
 import { cloneWithTransform } from "../helpers/clone-transform.js";
+import { isNumberParam, resolveParam } from "./param.js";
 import { MirrorFeature } from "../features/mirror-feature.js";
 import { RepeatMatrix } from "../features/repeat-matrix.js";
 import { resolveAxis, resolvePlane } from "../helpers/resolve.js";
@@ -66,12 +67,12 @@ function build(context) {
                 ? restObjects
                 : [context.getSceneObjects().at(-1)];
             if (type === 'linear') {
-                const counts = Array.isArray(options.count) ? options.count : [options.count];
+                const counts = Array.isArray(options.count) ? options.count : [resolveParam(options.count)];
                 const offsets = options.offset != null
-                    ? (Array.isArray(options.offset) ? options.offset : [options.offset])
+                    ? (Array.isArray(options.offset) ? options.offset : [resolveParam(options.offset)])
                     : null;
                 const lengths = 'length' in options && options.length != null
-                    ? (Array.isArray(options.length) ? options.length : [options.length])
+                    ? (Array.isArray(options.length) ? options.length : [resolveParam(options.length)])
                     : null;
                 const repeat = new RepeatLinear(axisSources, options, objects);
                 const transformedObjects = [];
@@ -139,14 +140,15 @@ function build(context) {
             if (type === 'circular') {
                 const axis = axisSources[0];
                 const circularOptions = options;
-                const { count, centered, skip } = circularOptions;
+                const count = resolveParam(circularOptions.count);
+                const { centered, skip } = circularOptions;
                 const repeat = new RepeatCircular(axis, circularOptions, objects);
                 let offset;
                 if ('offset' in circularOptions && circularOptions.offset !== undefined) {
-                    offset = circularOptions.offset;
+                    offset = resolveParam(circularOptions.offset);
                 }
                 else {
-                    const angle = circularOptions.angle;
+                    const angle = resolveParam(circularOptions.angle);
                     offset = angle % 360 === 0 ? angle / count : angle / (count - 1);
                 }
                 const startOffset = centered ? -(count * offset) / 2 : 0;
@@ -183,8 +185,8 @@ function build(context) {
             const axisArg = args[1];
             let angle = 90;
             let restStart = 2;
-            if (typeof args[2] === 'number') {
-                angle = args[2];
+            if (isNumberParam(args[2])) {
+                angle = resolveParam(args[2]);
                 restStart = 3;
             }
             const restObjects = args.slice(restStart);

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

@@ -1,5 +1,6 @@
 import { AxisLike } from "../math/axis.js";
 import { IRevolve, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RevolveFunction {
     /**
      * Revolves the last sketch 360 degrees around an axis.
@@ -13,7 +14,7 @@ interface RevolveFunction {
      * @param angle - The sweep angle in degrees
      * @param target - The sketch to revolve
      */
-    (axisLike: AxisLike, angle: number, target?: ISceneObject): IRevolve;
+    (axisLike: AxisLike, angle: NumberParam, target?: ISceneObject): IRevolve;
 }
 declare const _default: RevolveFunction;
 export default _default;

package/lib/dist/core/revolve.js

@@ -2,6 +2,7 @@ import { registerBuilder } from "../index.js";
 import { Revolve } from "../features/revolve.js";
 import { resolveAxis } from "../helpers/resolve.js";
 import { SceneObject } from "../common/scene-object.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -16,8 +17,8 @@ function build(context) {
         // (axis, angle)
         if (params.length === 2) {
             const axis = resolveAxis(params[0], context);
-            if (typeof params[1] === 'number') {
-                return new Revolve(axis, params[1], extrudable);
+            if (isNumberParam(params[1])) {
+                return new Revolve(axis, resolveParam(params[1]), extrudable);
             }
         }
         throw new Error("Invalid parameters for revolve function.");

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

@@ -1,4 +1,5 @@
 import { IRib, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface RibFunction {
     /**
      * Creates a rib from the last sketch with the given thickness.
@@ -6,13 +7,13 @@ interface RibFunction {
      * surrounding solids. Positive thickness = forward, negative = reverse.
      * @param thickness - Wall thickness (sign controls direction)
      */
-    (thickness: number): IRib;
+    (thickness: NumberParam): IRib;
     /**
      * Creates a rib from an explicit sketch spine with the given thickness.
      * @param thickness - Wall thickness (sign controls direction)
      * @param spine - The sketch providing the rib spine wire and plane
      */
-    (thickness: number, spine: ISceneObject): IRib;
+    (thickness: NumberParam, spine: ISceneObject): IRib;
 }
 declare const _default: RibFunction;
 export default _default;

package/lib/dist/core/rib.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { registerBuilder } from "../index.js";
 import { Rib } from "../features/rib.js";
+import { isNumberParam, resolveParam } from "./param.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
@@ -11,8 +12,11 @@ function build(context) {
         if (args.length === 0) {
             throw new Error("rib() requires at least a thickness argument.");
         }
-        const thickness = args[0];
-        if (typeof thickness !== 'number' || thickness === 0) {
+        if (!isNumberParam(args[0])) {
+            throw new Error("rib() thickness must be a non-zero number.");
+        }
+        const thickness = resolveParam(args[0]);
+        if (thickness === 0) {
             throw new Error("rib() thickness must be a non-zero number.");
         }
         let spine;

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

@@ -1,26 +1,27 @@
 import { AxisLike } from "../math/axis.js";
 import { IRotate, ISceneObject } from "./interfaces.js";
+import { type NumberParam, type BooleanParam } from "./param.js";
 interface RotateFunction {
     /**
      * [2D] Rotates geometry by an angle inside a sketch.
      * @param angle - The rotation angle in degrees
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [2D] Rotates geometry by an angle inside a sketch, optionally making a copy.
      * @param angle - The rotation angle in degrees
      * @param copy - Whether to copy instead of move
      * @param targets - The geometries to rotate (defaults to last object)
      */
-    (angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle.
      * @param axis - The axis to rotate around
      * @param angle - The rotation angle in degrees
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, ...targets: ISceneObject[]): IRotate;
     /**
      * [3D] Rotates objects around an axis by an angle, optionally making a copy.
      * @param axis - The axis to rotate around
@@ -28,7 +29,7 @@ interface RotateFunction {
      * @param copy - Whether to copy instead of move
      * @param targets - The objects to rotate (defaults to last object)
      */
-    (axis: AxisLike, angle: number, copy: boolean, ...targets: ISceneObject[]): IRotate;
+    (axis: AxisLike, angle: NumberParam, copy: BooleanParam, ...targets: ISceneObject[]): IRotate;
 }
 declare const _default: RotateFunction;
 export default _default;

package/lib/dist/core/rotate.js

@@ -5,6 +5,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { AxisObject } from "../features/axis.js";
 import { Rotate2D } from "../features/rotate2d.js";
+import { isBooleanParam, resolveParam } from "./param.js";
 function build(context) {
     return function rotate() {
         const args = Array.from(arguments);
@@ -15,13 +16,13 @@ function build(context) {
             targets.unshift(args.pop());
         }
         // Extract copy flag from the end (if boolean)
-        const copy = typeof args[args.length - 1] === 'boolean' ? args.pop() : false;
+        const copy = isBooleanParam(args[args.length - 1]) ? resolveParam(args.pop()) : false;
         // 2D: rotate(angle, copy?, ...targets)
         if (args.length === 1) {
             if (!activeSketch) {
                 throw new Error("rotate(angle) is only valid inside a sketch. For 3D rotation, specify an axis: rotate(axis, angle).");
             }
-            const angle = args[0];
+            const angle = resolveParam(args[0]);
             const rotate = new Rotate2D(angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;
@@ -40,7 +41,7 @@ function build(context) {
                 axis = new AxisObject(a);
                 context.addSceneObject(axis);
             }
-            const angle = args[1];
+            const angle = resolveParam(args[1]);
             const rotate = new Rotate(axis, angle, copy, ...targets);
             context.addSceneObject(rotate);
             return rotate;

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

@@ -1,16 +1,17 @@
 import { ISceneObject, IShell } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
 interface ShellFunction {
     /**
      * Hollows out a solid with the given wall thickness.
      * @param thickness - The wall thickness (defaults to 2.5)
      */
-    (thickness?: number): IShell;
+    (thickness?: NumberParam): IShell;
     /**
      * Hollows out a solid, removing the selected faces.
      * @param thickness - The wall thickness
      * @param selections - The face selections to remove
      */
-    (thickness: number, ...selections: ISceneObject[]): IShell;
+    (thickness: NumberParam, ...selections: ISceneObject[]): IShell;
 }
 declare const _default: ShellFunction;
 export default _default;