@bitbybit-dev/base 0.20.2 → 0.20.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c)2025 Bit By Bit Developers
+Copyright (c) 2025 Bit By Bit Developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/api/inputs/base-inputs.d.ts

@@ -18,6 +18,14 @@ export declare namespace Base {
         origin: Base.Point2;
         direction: Base.Vector2;
     };
+    type Segment2 = [Point2, Point2];
+    type Segment3 = [Point3, Point3];
+    type TrianglePlane3 = {
+        normal: Vector3;
+        d: number;
+    };
+    type Triangle3 = [Base.Point3, Base.Point3, Base.Point3];
+    type Mesh3 = Triangle3[];
     type Plane3 = {
         origin: Base.Point3;
         normal: Base.Vector3;

package/lib/api/inputs/index.d.ts

@@ -8,3 +8,6 @@ export * from "./vector-inputs";
 export * from "./transforms-inputs";
 export * from "./base-inputs";
 export * from "./dates-inputs";
+export * from "./line-inputs";
+export * from "./polyline-inputs";
+export * from "./mesh-inputs";

package/lib/api/inputs/index.js

@@ -8,3 +8,6 @@ export * from "./vector-inputs";
 export * from "./transforms-inputs";
 export * from "./base-inputs";
 export * from "./dates-inputs";
+export * from "./line-inputs";
+export * from "./polyline-inputs";
+export * from "./mesh-inputs";

package/lib/api/inputs/inputs.d.ts

@@ -8,3 +8,6 @@ export * from "./text-inputs";
 export * from "./vector-inputs";
 export * from "./transforms-inputs";
 export * from "./dates-inputs";
+export * from "./line-inputs";
+export * from "./polyline-inputs";
+export * from "./mesh-inputs";

package/lib/api/inputs/inputs.js

@@ -8,3 +8,6 @@ export * from "./text-inputs";
 export * from "./vector-inputs";
 export * from "./transforms-inputs";
 export * from "./dates-inputs";
+export * from "./line-inputs";
+export * from "./polyline-inputs";
+export * from "./mesh-inputs";

package/lib/api/inputs/line-inputs.d.ts

@@ -0,0 +1,240 @@
+import { Base } from "./base-inputs";
+export declare namespace Line {
+    class LinePointsDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(start?: Base.Point3, end?: Base.Point3);
+        /**
+         * Start point
+         * @default undefined
+         */
+        start?: Base.Point3;
+        /**
+         * End point
+         * @default undefined
+         */
+        end?: Base.Point3;
+    }
+    class LineStartEndPointsDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(startPoints?: Base.Point3[], endPoints?: Base.Point3[]);
+        /**
+         * Start points
+         * @default undefined
+         */
+        startPoints: Base.Point3[];
+        /**
+         * End points
+         * @default undefined
+         */
+        endPoints: Base.Point3[];
+    }
+    class DrawLineDto<T> {
+        /**
+         * Provide options without default values
+         */
+        constructor(line?: LinePointsDto, opacity?: number, colours?: string | string[], size?: number, updatable?: boolean, lineMesh?: T);
+        /**
+         * Line
+         * @default undefined
+         */
+        line?: LinePointsDto;
+        /**
+         * Value between 0 and 1
+         * @default 1
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        opacity?: number;
+        /**
+         * Hex colour string
+         * @default #444444
+         */
+        colours?: string | string[];
+        /**
+         * Width of the line
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        size?: number;
+        /**
+         * Indicates wether the position of this line will change in time
+         * @default false
+         */
+        updatable?: boolean;
+        /**
+         * Line mesh variable in case it already exists and needs updating
+         * @default undefined
+         */
+        lineMesh?: T;
+    }
+    class DrawLinesDto<T> {
+        /**
+         * Provide options without default values
+         */
+        constructor(lines?: LinePointsDto[], opacity?: number, colours?: string | string[], size?: number, updatable?: boolean, linesMesh?: T);
+        /**
+         * Lines
+         * @default undefined
+         */
+        lines?: LinePointsDto[];
+        /**
+         * Value between 0 and 1
+         * @default 1
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        opacity?: number;
+        /**
+         * Hex colour string
+         * @default #444444
+         */
+        colours?: string | string[];
+        /**
+         * Width of the line
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        size?: number;
+        /**
+         * Indicates wether the position of these lines will change in time
+         * @default false
+         */
+        updatable?: boolean;
+        /**
+         * Line mesh variable in case it already exists and needs updating
+         * @default undefined
+         */
+        linesMesh?: T;
+    }
+    class PointsLinesDto {
+        constructor(points?: Base.Point3[]);
+        /**
+         * Points
+         * @default undefined
+         */
+        points?: Base.Point3[];
+    }
+    class LineDto {
+        constructor(line?: LinePointsDto);
+        /**
+         * Line to convert
+         * @default undefined
+         */
+        line?: LinePointsDto;
+    }
+    class SegmentDto {
+        constructor(segment?: Base.Segment3);
+        /**
+         * Segment
+         * @default undefined
+         */
+        segment?: Base.Segment3;
+    }
+    class SegmentsDto {
+        constructor(segments?: Base.Segment3[]);
+        /**
+         * Segments
+         * @default undefined
+         */
+        segments?: Base.Segment3[];
+    }
+    class LinesDto {
+        constructor(lines?: LinePointsDto[]);
+        /**
+         * Lines to convert
+         * @default undefined
+         */
+        lines?: LinePointsDto[];
+    }
+    class LineLineIntersectionDto {
+        constructor(line1?: LinePointsDto, line2?: LinePointsDto, tolerance?: number);
+        /**
+         * First line
+         * @default undefined
+         */
+        line1?: LinePointsDto;
+        /**
+         * Second line
+         * @default undefined
+         */
+        line2?: LinePointsDto;
+        /**
+         * Set to false if you want to check for infinite lines
+         * @default true
+         */
+        checkSegmentsOnly?: boolean;
+        /**
+         * Tolerance for intersection
+         * @default 0.01
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        tolerance?: number;
+    }
+    class PointOnLineDto {
+        constructor(line?: LinePointsDto, param?: number);
+        /**
+         * Line to get point on
+         * @default undefined
+         */
+        line?: LinePointsDto;
+        /**
+         * Param to use for point on line
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        param?: number;
+    }
+    class TransformLineDto {
+        constructor(line?: LinePointsDto, transformation?: Base.TransformMatrixes);
+        /**
+         * Line to transform
+         * @default undefined
+         */
+        line?: LinePointsDto;
+        /**
+         * Transformation matrix or a list of transformation matrixes
+         * @default undefined
+         */
+        transformation?: Base.TransformMatrixes;
+    }
+    class TransformsLinesDto {
+        constructor(lines?: LinePointsDto[], transformation?: Base.TransformMatrixes[]);
+        /**
+         * Lines to transform
+         * @default undefined
+         */
+        lines?: LinePointsDto[];
+        /**
+         * Transformations matrix or a list of transformations matrixes
+         * @default undefined
+         */
+        transformation?: Base.TransformMatrixes[];
+    }
+    class TransformLinesDto {
+        constructor(lines?: LinePointsDto[], transformation?: Base.TransformMatrixes);
+        /**
+         * Lines to transform
+         * @default undefined
+         */
+        lines?: LinePointsDto[];
+        /**
+         * Transformation matrix or a list of transformation matrixes
+         * @default undefined
+         */
+        transformation?: Base.TransformMatrixes;
+    }
+}

package/lib/api/inputs/line-inputs.js

@@ -0,0 +1,247 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+export var Line;
+(function (Line) {
+    class LinePointsDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(start, end) {
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+        }
+    }
+    Line.LinePointsDto = LinePointsDto;
+    class LineStartEndPointsDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(startPoints, endPoints) {
+            if (startPoints !== undefined) {
+                this.startPoints = startPoints;
+            }
+            if (endPoints !== undefined) {
+                this.endPoints = endPoints;
+            }
+        }
+    }
+    Line.LineStartEndPointsDto = LineStartEndPointsDto;
+    class DrawLineDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(line, opacity, colours, size, updatable, lineMesh) {
+            /**
+             * Value between 0 and 1
+             * @default 1
+             * @minimum 0
+             * @maximum 1
+             * @step 0.1
+             */
+            this.opacity = 1;
+            /**
+             * Hex colour string
+             * @default #444444
+             */
+            this.colours = "#444444";
+            /**
+             * Width of the line
+             * @default 3
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.size = 3;
+            /**
+             * Indicates wether the position of this line will change in time
+             * @default false
+             */
+            this.updatable = false;
+            if (line !== undefined) {
+                this.line = line;
+            }
+            if (opacity !== undefined) {
+                this.opacity = opacity;
+            }
+            if (colours !== undefined) {
+                this.colours = colours;
+            }
+            if (size !== undefined) {
+                this.size = size;
+            }
+            if (updatable !== undefined) {
+                this.updatable = updatable;
+            }
+            if (lineMesh !== undefined) {
+                this.lineMesh = lineMesh;
+            }
+        }
+    }
+    Line.DrawLineDto = DrawLineDto;
+    class DrawLinesDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(lines, opacity, colours, size, updatable, linesMesh) {
+            /**
+             * Value between 0 and 1
+             * @default 1
+             * @minimum 0
+             * @maximum 1
+             * @step 0.1
+             */
+            this.opacity = 1;
+            /**
+             * Hex colour string
+             * @default #444444
+             */
+            this.colours = "#444444";
+            /**
+             * Width of the line
+             * @default 3
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.size = 3;
+            /**
+             * Indicates wether the position of these lines will change in time
+             * @default false
+             */
+            this.updatable = false;
+            if (lines !== undefined) {
+                this.lines = lines;
+            }
+            if (opacity !== undefined) {
+                this.opacity = opacity;
+            }
+            if (colours !== undefined) {
+                this.colours = colours;
+            }
+            if (size !== undefined) {
+                this.size = size;
+            }
+            if (updatable !== undefined) {
+                this.updatable = updatable;
+            }
+            if (linesMesh !== undefined) {
+                this.linesMesh = linesMesh;
+            }
+        }
+    }
+    Line.DrawLinesDto = DrawLinesDto;
+    class PointsLinesDto {
+        constructor(points) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+        }
+    }
+    Line.PointsLinesDto = PointsLinesDto;
+    class LineDto {
+        constructor(line) {
+            if (line !== undefined) {
+                this.line = line;
+            }
+        }
+    }
+    Line.LineDto = LineDto;
+    class SegmentDto {
+        constructor(segment) {
+            if (segment !== undefined) {
+                this.segment = segment;
+            }
+        }
+    }
+    Line.SegmentDto = SegmentDto;
+    class SegmentsDto {
+        constructor(segments) {
+            if (segments !== undefined) {
+                this.segments = segments;
+            }
+        }
+    }
+    Line.SegmentsDto = SegmentsDto;
+    class LinesDto {
+        constructor(lines) {
+            if (lines !== undefined) {
+                this.lines = lines;
+            }
+        }
+    }
+    Line.LinesDto = LinesDto;
+    class LineLineIntersectionDto {
+        constructor(line1, line2, tolerance) {
+            /**
+             * Set to false if you want to check for infinite lines
+             * @default true
+             */
+            this.checkSegmentsOnly = true;
+            if (line1 !== undefined) {
+                this.line1 = line1;
+            }
+            if (line2 !== undefined) {
+                this.line2 = line2;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Line.LineLineIntersectionDto = LineLineIntersectionDto;
+    class PointOnLineDto {
+        constructor(line, param) {
+            /**
+             * Param to use for point on line
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.param = 0.5;
+            if (line !== undefined) {
+                this.line = line;
+            }
+            if (param !== undefined) {
+                this.param = param;
+            }
+        }
+    }
+    Line.PointOnLineDto = PointOnLineDto;
+    class TransformLineDto {
+        constructor(line, transformation) {
+            if (line !== undefined) {
+                this.line = line;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Line.TransformLineDto = TransformLineDto;
+    class TransformsLinesDto {
+        constructor(lines, transformation) {
+            if (lines !== undefined) {
+                this.lines = lines;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Line.TransformsLinesDto = TransformsLinesDto;
+    class TransformLinesDto {
+        constructor(lines, transformation) {
+            if (lines !== undefined) {
+                this.lines = lines;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Line.TransformLinesDto = TransformLinesDto;
+})(Line || (Line = {}));

package/lib/api/inputs/mesh-inputs.d.ts

@@ -0,0 +1,82 @@
+import { Base } from "./base-inputs";
+export declare namespace Mesh {
+    class SignedDistanceFromPlaneToPointDto {
+        constructor(point?: Base.Point3, plane?: Base.TrianglePlane3);
+        /**
+         * Point from which to find the distance
+         * @default undefined
+         */
+        point?: Base.Point3;
+        /**
+         * Triangle plane to which the distance is calculated
+         * @default undefined
+         */
+        plane?: Base.TrianglePlane3;
+    }
+    class TriangleDto {
+        constructor(triangle?: Base.Triangle3);
+        /**
+         * Triangle to be used
+         * @default undefined
+         */
+        triangle?: Base.Triangle3;
+    }
+    class TriangleToleranceDto {
+        constructor(triangle?: Base.Triangle3);
+        /**
+         * Triangle to be used
+         * @default undefined
+         */
+        triangle?: Base.Triangle3;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance?: number;
+    }
+    class TriangleTriangleToleranceDto {
+        constructor(triangle1?: Base.Triangle3, triangle2?: Base.Triangle3, tolerance?: number);
+        /**
+         * First triangle
+         * @default undefined
+         */
+        triangle1?: Base.Triangle3;
+        /**
+         * Second triangle
+         * @default undefined
+         */
+        triangle2?: Base.Triangle3;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance?: number;
+    }
+    class MeshMeshToleranceDto {
+        constructor(mesh1?: Base.Mesh3, mesh2?: Base.Mesh3, tolerance?: number);
+        /**
+         * First mesh
+         * @default undefined
+         */
+        mesh1?: Base.Mesh3;
+        /**
+         * Second mesh
+         * @default undefined
+         */
+        mesh2?: Base.Mesh3;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance?: number;
+    }
+}

package/lib/api/inputs/mesh-inputs.js

@@ -0,0 +1,83 @@
+// tslint:disable-next-line: no-namespace
+export var Mesh;
+(function (Mesh) {
+    class SignedDistanceFromPlaneToPointDto {
+        constructor(point, plane) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (plane !== undefined) {
+                this.plane = plane;
+            }
+        }
+    }
+    Mesh.SignedDistanceFromPlaneToPointDto = SignedDistanceFromPlaneToPointDto;
+    class TriangleDto {
+        constructor(triangle) {
+            if (triangle !== undefined) {
+                this.triangle = triangle;
+            }
+        }
+    }
+    Mesh.TriangleDto = TriangleDto;
+    class TriangleToleranceDto {
+        constructor(triangle) {
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (triangle !== undefined) {
+                this.triangle = triangle;
+            }
+        }
+    }
+    Mesh.TriangleToleranceDto = TriangleToleranceDto;
+    class TriangleTriangleToleranceDto {
+        constructor(triangle1, triangle2, tolerance) {
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (triangle1 !== undefined) {
+                this.triangle1 = triangle1;
+            }
+            if (triangle2 !== undefined) {
+                this.triangle2 = triangle2;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Mesh.TriangleTriangleToleranceDto = TriangleTriangleToleranceDto;
+    class MeshMeshToleranceDto {
+        constructor(mesh1, mesh2, tolerance) {
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (mesh1 !== undefined) {
+                this.mesh1 = mesh1;
+            }
+            if (mesh2 !== undefined) {
+                this.mesh2 = mesh2;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Mesh.MeshMeshToleranceDto = MeshMeshToleranceDto;
+})(Mesh || (Mesh = {}));