fluidcad 0.0.25 → 0.0.27

package/lib/dist/common/scene-object.d.ts

@@ -3,9 +3,6 @@ import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
-import type { AxisLike } from "../math/axis.js";
-import type { PlaneLike } from "../math/plane.js";
-import type { PointLike } from "../math/point.js";
 export type SourceLocation = {
     filePath: string;
     line: number;
@@ -61,15 +58,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     abstract getType(): string;
     abstract build(context?: BuildSceneObjectContext): void;
     getAppliedTransform(): Matrix4 | null;
-    transform(matrix: Matrix4): this;
-    translate(x: number): this;
-    translate(x: number, y: number): this;
-    translate(x: number, y: number, z: number): this;
-    translate(p: PointLike): this;
-    rotate(angle: number): this;
-    rotate(axis: AxisLike, angle: number): this;
-    mirror(plane: PlaneLike): this;
-    mirror(axis: AxisLike): this;
+    protected composeAppliedTransform(matrix: Matrix4): void;
     compareTo(other: SceneObject): boolean;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -118,9 +107,10 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getOperationMode(): OperationMode;
     isSymmetric(): boolean;
     resolveFusionScope(sceneObjects: SceneObject[]): SceneObject[];
-    add(...objects: ISceneObject[]): this;
+    add(): this;
     new(): this;
-    remove(...objects: ISceneObject[]): this;
+    remove(): this;
+    scope(...objects: ISceneObject[]): this;
     symmetric(): this;
     /**
      * Called after all objects have been built. Override to perform

package/lib/dist/common/scene-object.js

@@ -1,8 +1,4 @@
 import { randomUUID } from "crypto";
-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";
 export class SceneObject {
     state;
     children = [];
@@ -97,55 +93,10 @@ export class SceneObject {
     getAppliedTransform() {
         return this._appliedTransform;
     }
-    transform(matrix) {
+    composeAppliedTransform(matrix) {
         this._appliedTransform = this._appliedTransform
             ? matrix.multiply(this._appliedTransform)
             : matrix;
-        return this;
-    }
-    translate(a, b, c) {
-        let x, y, z;
-        if (typeof a === 'number') {
-            x = a;
-            y = b ?? 0;
-            z = c ?? 0;
-        }
-        else if (Array.isArray(a)) {
-            x = a[0] ?? 0;
-            y = a[1] ?? 0;
-            z = a[2] ?? 0;
-        }
-        else {
-            x = a.x;
-            y = a.y;
-            z = a.z;
-        }
-        return this.transform(Matrix4.fromTranslation(x, y, z));
-    }
-    rotate(a, b) {
-        let origin;
-        let direction;
-        let angleDeg;
-        if (typeof a === 'number') {
-            origin = new Point(0, 0, 0);
-            direction = Vector3d.unitZ();
-            angleDeg = a;
-        }
-        else {
-            const resolved = resolveAxisLike(a);
-            origin = resolved.origin;
-            direction = resolved.direction;
-            angleDeg = b;
-        }
-        return this.transform(Matrix4.fromRotationAroundAxis(origin, direction, rad(angleDeg)));
-    }
-    mirror(arg) {
-        if (isAxisLikeArg(arg)) {
-            const axis = resolveAxisLike(arg);
-            return this.transform(Matrix4.mirrorAxis(axis.origin, axis.direction));
-        }
-        const plane = resolvePlaneLike(arg);
-        return this.transform(Matrix4.mirrorPlane(plane.normal, plane.origin));
     }
     compareTo(other) {
         const match = this._guide === other._guide && this._reusable === other._reusable;
@@ -419,17 +370,9 @@ export class SceneObject {
         }
         return sceneObjects;
     }
-    add(...objects) {
+    add() {
         this._operationMode = 'add';
-        if (objects.length === 0) {
-            this._fusionScope = 'all';
-        }
-        else if (objects.length === 1) {
-            this._fusionScope = objects[0];
-        }
-        else {
-            this._fusionScope = objects;
-        }
+        this._fusionScope = 'all';
         return this;
     }
     new() {
@@ -437,15 +380,16 @@ export class SceneObject {
         this._fusionScope = 'none';
         return this;
     }
-    remove(...objects) {
+    remove() {
         this._operationMode = 'remove';
-        if (objects.length === 0) {
-            this._fusionScope = 'all';
-        }
-        else if (objects.length === 1) {
+        this._fusionScope = 'all';
+        return this;
+    }
+    scope(...objects) {
+        if (objects.length === 1) {
             this._fusionScope = objects[0];
         }
-        else {
+        else if (objects.length > 1) {
             this._fusionScope = objects;
         }
         return this;
@@ -463,64 +407,3 @@ export class SceneObject {
         return `${this.getOrder()}-${this.getUniqueType()}-${suffix}`;
     }
 }
-function isAxisLikeArg(arg) {
-    if (arg === 'x' || arg === 'y' || arg === 'z') {
-        return true;
-    }
-    if (arg && typeof arg === 'object') {
-        if (typeof arg.getAxis === 'function') {
-            return true;
-        }
-        if (arg.origin && arg.direction) {
-            return true;
-        }
-    }
-    return false;
-}
-function resolveAxisLike(arg) {
-    if (arg === 'x') {
-        return { origin: new Point(0, 0, 0), direction: Vector3d.unitX() };
-    }
-    if (arg === 'y') {
-        return { origin: new Point(0, 0, 0), direction: Vector3d.unitY() };
-    }
-    if (arg === 'z') {
-        return { origin: new Point(0, 0, 0), direction: Vector3d.unitZ() };
-    }
-    const a = arg;
-    if (typeof a.getAxis === 'function') {
-        const axis = a.getAxis();
-        return { origin: axis.origin, direction: axis.direction };
-    }
-    return { origin: a.origin, direction: a.direction };
-}
-function resolvePlaneLike(arg) {
-    if (typeof arg === 'string') {
-        switch (arg) {
-            case 'xy':
-            case 'top':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ() };
-            case '-xy':
-            case 'bottom':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ().multiply(-1) };
-            case 'xz':
-            case 'front':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY().multiply(-1) };
-            case '-xz':
-            case 'back':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY() };
-            case 'yz':
-            case 'right':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX() };
-            case '-yz':
-            case 'left':
-                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX().multiply(-1) };
-        }
-    }
-    const p = arg;
-    if (typeof p.getPlane === 'function') {
-        const plane = p.getPlane();
-        return { origin: plane.origin, normal: plane.normal };
-    }
-    return { origin: p.origin, normal: p.normal };
-}

package/lib/dist/common/shape-factory.d.ts

@@ -4,5 +4,5 @@ import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Wire | Edge | Solid | Face;
+    static fromShape(shape: TopoDS_Shape): Wire | Edge | Face | Solid;
 }

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

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

package/lib/dist/common/shapes.js

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

package/lib/dist/common/transformable-primitive.d.ts

@@ -0,0 +1,16 @@
+import { SceneObject } from "./scene-object.js";
+import { Matrix4 } from "../math/matrix4.js";
+import type { AxisLike } from "../math/axis.js";
+import type { PlaneLike } from "../math/plane.js";
+import type { PointLike } from "../math/point.js";
+export declare abstract class TransformablePrimitive extends SceneObject {
+    transform(matrix: Matrix4): this;
+    translate(x: number): this;
+    translate(x: number, y: number): this;
+    translate(x: number, y: number, z: number): this;
+    translate(p: PointLike): this;
+    rotate(angle: number): this;
+    rotate(axis: AxisLike, angle: number): this;
+    mirror(plane: PlaneLike): this;
+    mirror(axis: AxisLike): this;
+}

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

@@ -0,0 +1,116 @@
+import { SceneObject } from "./scene-object.js";
+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";
+export class TransformablePrimitive extends SceneObject {
+    transform(matrix) {
+        this.composeAppliedTransform(matrix);
+        return this;
+    }
+    translate(a, b, c) {
+        let x, y, z;
+        if (typeof a === 'number') {
+            x = a;
+            y = b ?? 0;
+            z = c ?? 0;
+        }
+        else if (Array.isArray(a)) {
+            x = a[0] ?? 0;
+            y = a[1] ?? 0;
+            z = a[2] ?? 0;
+        }
+        else {
+            x = a.x;
+            y = a.y;
+            z = a.z;
+        }
+        return this.transform(Matrix4.fromTranslation(x, y, z));
+    }
+    rotate(a, b) {
+        let origin;
+        let direction;
+        let angleDeg;
+        if (typeof a === 'number') {
+            origin = new Point(0, 0, 0);
+            direction = Vector3d.unitZ();
+            angleDeg = a;
+        }
+        else {
+            const resolved = resolveAxisLike(a);
+            origin = resolved.origin;
+            direction = resolved.direction;
+            angleDeg = b;
+        }
+        return this.transform(Matrix4.fromRotationAroundAxis(origin, direction, rad(angleDeg)));
+    }
+    mirror(arg) {
+        if (isAxisLikeArg(arg)) {
+            const axis = resolveAxisLike(arg);
+            return this.transform(Matrix4.mirrorAxis(axis.origin, axis.direction));
+        }
+        const plane = resolvePlaneLike(arg);
+        return this.transform(Matrix4.mirrorPlane(plane.normal, plane.origin));
+    }
+}
+function isAxisLikeArg(arg) {
+    if (arg === 'x' || arg === 'y' || arg === 'z') {
+        return true;
+    }
+    if (arg && typeof arg === 'object') {
+        if (typeof arg.getAxis === 'function') {
+            return true;
+        }
+        if (arg.origin && arg.direction) {
+            return true;
+        }
+    }
+    return false;
+}
+function resolveAxisLike(arg) {
+    if (arg === 'x') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitX() };
+    }
+    if (arg === 'y') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitY() };
+    }
+    if (arg === 'z') {
+        return { origin: new Point(0, 0, 0), direction: Vector3d.unitZ() };
+    }
+    const a = arg;
+    if (typeof a.getAxis === 'function') {
+        const axis = a.getAxis();
+        return { origin: axis.origin, direction: axis.direction };
+    }
+    return { origin: a.origin, direction: a.direction };
+}
+function resolvePlaneLike(arg) {
+    if (typeof arg === 'string') {
+        switch (arg) {
+            case 'xy':
+            case 'top':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ() };
+            case '-xy':
+            case 'bottom':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitZ().multiply(-1) };
+            case 'xz':
+            case 'front':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY().multiply(-1) };
+            case '-xz':
+            case 'back':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitY() };
+            case 'yz':
+            case 'right':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX() };
+            case '-yz':
+            case 'left':
+                return { origin: new Point(0, 0, 0), normal: Vector3d.unitX().multiply(-1) };
+        }
+    }
+    const p = arg;
+    if (typeof p.getPlane === 'function') {
+        const plane = p.getPlane();
+        return { origin: plane.origin, normal: plane.normal };
+    }
+    return { origin: p.origin, normal: p.normal };
+}

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

@@ -1,23 +1,23 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface ChamferFunction {
     /**
      * Chamfers selected edges with the given distance.
      * @param distance - The chamfer distance (defaults to 1)
      */
-    (distance?: number): ITransformable;
+    (distance?: number): ISceneObject;
     /**
      * Chamfers the given edge selections with the given distance.
      * @param distance - The chamfer distance
      * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, ...sceneObjects: ISceneObject[]): ITransformable;
+    (distance: number, ...sceneObjects: ISceneObject[]): ISceneObject;
     /**
      * Chamfers selected edges with two distances or a distance and angle.
      * @param distance - The first chamfer distance
      * @param distance2 - The second distance, or angle if `isAngle` is true
      * @param isAngle - Whether `distance2` is an angle
      */
-    (distance: number, distance2: number, isAngle?: boolean): ITransformable;
+    (distance: number, distance2: number, isAngle?: boolean): ISceneObject;
     /**
      * Chamfers the given edge selections with two distances or a distance and angle.
      * @param distance - The first chamfer distance
@@ -25,7 +25,7 @@ interface ChamferFunction {
      * @param isAngle - Whether `distance2` is an angle
      * @param sceneObjects - The edge selections to chamfer
      */
-    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ITransformable;
+    (distance: number, distance2: number, isAngle: boolean, ...sceneObjects: ISceneObject[]): ISceneObject;
 }
 declare const _default: ChamferFunction;
 export default _default;

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

@@ -1,16 +1,16 @@
-import { ISceneObject, ITransformable } from "./interfaces.js";
+import { ISceneObject } from "./interfaces.js";
 interface ColorFunction {
     /**
      * Applies a color to the last selection.
      * @param color - The color value (CSS color string)
      */
-    (color: string): ITransformable;
+    (color: string): ISceneObject;
     /**
      * Applies a color to the given selection.
      * @param color - The color value (CSS color string)
      * @param selection - The face or edge selection to color
      */
-    (color: string, selection: ISceneObject): ITransformable;
+    (color: string, selection: ISceneObject): ISceneObject;
 }
 declare const _default: ColorFunction;
 export default _default;

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

@@ -2,45 +2,44 @@ import { IExtrude, ISceneObject } from "./interfaces.js";
 interface ExtrudeFunction {
     /**
      * Extrudes the last sketch with a default distance.
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch by a given distance.
+     * Extrudes by a given distance.
      * @param distance - The extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance: number, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch between two distances.
+     * Extrudes between two distances.
      * @param distance1 - The first extrusion distance
      * @param distance2 - The second extrusion distance
-     * @param target - The sketch to extrude
      */
     (distance1: number, distance2: number): IExtrude;
     /**
-     * Extrudes the given sketch between two distances.
+     * Extrudes between two distances.
      * @param distance1 - The first extrusion distance
      * @param distance2 - The second extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance1: number, distance2: number, target: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to a specific face.
+     * Extrudes up to a specific face.
      * @param face - A face selection to extrude up to
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: ISceneObject, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the first intersecting face.
+     * Extrudes up to the first intersecting face.
      * @param face - The literal `'first-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'first-face', target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the last intersecting face.
+     * Extrudes up to the last intersecting face.
      * @param face - The literal `'last-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'last-face', target?: ISceneObject): IExtrude;
 }

package/lib/dist/core/extrude.js

@@ -3,9 +3,22 @@ import { registerBuilder } from "../index.js";
 import { Extrude } from "../features/extrude.js";
 import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
 import { ExtrudeToFace } from "../features/extrude-to-face.js";
+import { SelectSceneObject } from "../features/select.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
+function isFaceSource(obj) {
+    if (!(obj instanceof SceneObject)) {
+        return false;
+    }
+    if (isExtrudable(obj)) {
+        return false;
+    }
+    if (obj instanceof SelectSceneObject) {
+        return obj.shapeType() === 'face';
+    }
+    return true;
+}
 function build(context) {
     function doExtrude(params, extrudable) {
         const defaultDistance = 25;
@@ -41,8 +54,13 @@ function build(context) {
     return function extrude() {
         const args = [...arguments];
         let extrudable;
-        if (args.length > 0 && isExtrudable(args[args.length - 1])) {
+        const last = args.length > 0 ? args[args.length - 1] : undefined;
+        if (last !== undefined && isExtrudable(last)) {
+            extrudable = args.pop();
+        }
+        else if (last !== undefined && args.length >= 2 && isFaceSource(last)) {
             extrudable = args.pop();
+            context.addSceneObject(extrudable);
         }
         else {
             extrudable = context.getLastExtrudable() || undefined;

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

@@ -1,33 +1,33 @@
-import { IGeometry, ISceneObject, ITransformable } from "./interfaces.js";
+import { IGeometry, ISceneObject } from "./interfaces.js";
 interface FilletFunction {
     /**
      * Fillets selected edges with the given radius.
      * @param radius - The fillet radius (defaults to 1)
      */
-    (radius?: number): ITransformable;
+    (radius?: number): ISceneObject;
     /**
      * Fillets the given edge selections with the given radius.
      * @param radius - The fillet radius
      * @param sceneObjects - The edge selections to fillet
      */
-    (radius: number, ...sceneObjects: ISceneObject[]): ITransformable;
+    (radius: number, ...sceneObjects: ISceneObject[]): ISceneObject;
     /**
      * [2D] Fillets corners between the given geometries.
      * @param objects - The geometries whose corners to fillet
      */
-    (objects: IGeometry[]): ITransformable;
+    (objects: IGeometry[]): ISceneObject;
     /**
      * [2D] Fillets corners between the given geometries with a radius.
      * @param objects - The geometries whose corners to fillet
      * @param radius - The fillet radius
      */
-    (objects: IGeometry[], radius: number): ITransformable;
+    (objects: IGeometry[], radius: number): ISceneObject;
     /**
      * [2D] Fillets corners at the given radius and geometries.
      * @param radius - The fillet radius
      * @param objects - The geometries whose corners to fillet
      */
-    (radius: number, ...objects: IGeometry[]): ITransformable;
+    (radius: number, ...objects: IGeometry[]): ISceneObject;
 }
 declare const _default: FilletFunction;
 export default _default;

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IFuseable, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";