@bitbybit-dev/base 0.19.0-alpha.0

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

@@ -0,0 +1,136 @@
+import { Base } from "./base-inputs";
+export declare namespace Transforms {
+    class RotationCenterAxisDto {
+        constructor(angle?: number, axis?: Base.Vector3, center?: Base.Point3);
+        /**
+         * Angle of rotation in degrees
+         * @default 90
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        angle: number;
+        /**
+         * Axis vector for rotation
+         * @default [0, 1, 0]
+         */
+        axis: Base.Vector3;
+        /**
+         * The center from which the axis is pointing
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3;
+    }
+    class RotationCenterDto {
+        constructor(angle?: number, center?: Base.Point3);
+        /**
+         * Angle of rotation in degrees
+         * @default 90
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        angle: number;
+        /**
+         * The center from which the axis is pointing
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3;
+    }
+    class RotationCenterYawPitchRollDto {
+        constructor(yaw?: number, pitch?: number, roll?: number, center?: Base.Point3);
+        /**
+         * Yaw angle (Rotation around X) in degrees
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        yaw: number;
+        /**
+         * Pitch angle (Rotation around Y) in degrees
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        pitch: number;
+        /**
+         * Roll angle (Rotation around Z) in degrees
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        roll: number;
+        /**
+         * The center from which the rotations are applied
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3;
+    }
+    class ScaleXYZDto {
+        constructor(scaleXyz?: Base.Vector3);
+        /**
+         * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
+         * @default [1, 1, 1]
+         */
+        scaleXyz: Base.Vector3;
+    }
+    class ScaleCenterXYZDto {
+        constructor(center?: Base.Point3, scaleXyz?: Base.Vector3);
+        /**
+         * The center from which the scaling is applied
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3;
+        /**
+         * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
+         * @default [1, 1, 1]
+         */
+        scaleXyz: Base.Vector3;
+    }
+    class UniformScaleDto {
+        constructor(scale?: number);
+        /**
+         * Uniform scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        scale: number;
+    }
+    class UniformScaleFromCenterDto {
+        constructor(scale?: number, center?: Base.Point3);
+        /**
+         * Scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        scale: number;
+        /**
+         * Center position of the scaling
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3;
+    }
+    class TranslationXYZDto {
+        constructor(translation?: Base.Vector3);
+        /**
+         * Translation vector with [x, y, z] distances
+         * @default [0, 0, 0]
+         */
+        translation: Base.Vector3;
+    }
+    class TranslationsXYZDto {
+        constructor(translations?: Base.Vector3[]);
+        /**
+         * Translation vectors with [x, y, z] distances
+         * @default undefined
+         */
+        translations: Base.Vector3[];
+    }
+}

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

@@ -0,0 +1,200 @@
+export var Transforms;
+(function (Transforms) {
+    class RotationCenterAxisDto {
+        constructor(angle, axis, center) {
+            /**
+             * Angle of rotation in degrees
+             * @default 90
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1
+             */
+            this.angle = 90;
+            /**
+             * Axis vector for rotation
+             * @default [0, 1, 0]
+             */
+            this.axis = [0, 1, 0];
+            /**
+             * The center from which the axis is pointing
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            if (angle !== undefined) {
+                this.angle = angle;
+            }
+            if (axis !== undefined) {
+                this.axis = axis;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+        }
+    }
+    Transforms.RotationCenterAxisDto = RotationCenterAxisDto;
+    class RotationCenterDto {
+        constructor(angle, center) {
+            /**
+             * Angle of rotation in degrees
+             * @default 90
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1
+             */
+            this.angle = 90;
+            /**
+             * The center from which the axis is pointing
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            if (angle !== undefined) {
+                this.angle = angle;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+        }
+    }
+    Transforms.RotationCenterDto = RotationCenterDto;
+    class RotationCenterYawPitchRollDto {
+        constructor(yaw, pitch, roll, center) {
+            /**
+             * Yaw angle (Rotation around X) in degrees
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1
+             */
+            this.yaw = 0;
+            /**
+             * Pitch angle (Rotation around Y) in degrees
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1
+             */
+            this.pitch = 0;
+            /**
+             * Roll angle (Rotation around Z) in degrees
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1
+             */
+            this.roll = 0;
+            /**
+             * The center from which the rotations are applied
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            if (yaw !== undefined) {
+                this.yaw = yaw;
+            }
+            if (pitch !== undefined) {
+                this.pitch = pitch;
+            }
+            if (roll !== undefined) {
+                this.roll = roll;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+        }
+    }
+    Transforms.RotationCenterYawPitchRollDto = RotationCenterYawPitchRollDto;
+    class ScaleXYZDto {
+        constructor(scaleXyz) {
+            /**
+             * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
+             * @default [1, 1, 1]
+             */
+            this.scaleXyz = [1, 1, 1];
+            if (scaleXyz !== undefined) {
+                this.scaleXyz = scaleXyz;
+            }
+        }
+    }
+    Transforms.ScaleXYZDto = ScaleXYZDto;
+    class ScaleCenterXYZDto {
+        constructor(center, scaleXyz) {
+            /**
+             * The center from which the scaling is applied
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            /**
+             * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
+             * @default [1, 1, 1]
+             */
+            this.scaleXyz = [1, 1, 1];
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (scaleXyz !== undefined) {
+                this.scaleXyz = scaleXyz;
+            }
+        }
+    }
+    Transforms.ScaleCenterXYZDto = ScaleCenterXYZDto;
+    class UniformScaleDto {
+        constructor(scale) {
+            /**
+             * Uniform scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.scale = 1;
+            if (scale !== undefined) {
+                this.scale = scale;
+            }
+        }
+    }
+    Transforms.UniformScaleDto = UniformScaleDto;
+    class UniformScaleFromCenterDto {
+        constructor(scale, center) {
+            /**
+             * Scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.scale = 1;
+            /**
+             * Center position of the scaling
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            if (scale !== undefined) {
+                this.scale = scale;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+        }
+    }
+    Transforms.UniformScaleFromCenterDto = UniformScaleFromCenterDto;
+    class TranslationXYZDto {
+        constructor(translation) {
+            /**
+             * Translation vector with [x, y, z] distances
+             * @default [0, 0, 0]
+             */
+            this.translation = [0, 0, 0];
+            if (translation !== undefined) {
+                this.translation = translation;
+            }
+        }
+    }
+    Transforms.TranslationXYZDto = TranslationXYZDto;
+    class TranslationsXYZDto {
+        constructor(translations) {
+            if (translations !== undefined) {
+                this.translations = translations;
+            }
+        }
+    }
+    Transforms.TranslationsXYZDto = TranslationsXYZDto;
+})(Transforms || (Transforms = {}));

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

@@ -0,0 +1,300 @@
+import { Base } from "./base-inputs";
+import { Math } from "./inputs";
+export declare namespace Vector {
+    class TwoVectorsDto {
+        constructor(first?: number[], second?: number[]);
+        /**
+         * First vector
+         * @default undefined
+         */
+        first: number[];
+        /**
+         * Second vector
+         * @default undefined
+         */
+        second: number[];
+    }
+    class VectorBoolDto {
+        constructor(vector?: boolean[]);
+        /**
+         * Vector of booleans
+         * @default undefined
+         */
+        vector: boolean[];
+    }
+    class RemoveAllDuplicateVectorsDto {
+        constructor(vectors?: number[][], tolerance?: number);
+        /**
+         * Vectors array
+         * @default undefined
+         */
+        vectors: number[][];
+        /**
+         * Tolerance value
+         * @default 1e-7
+         * @minimum 0
+         * @maximum Infinity
+         */
+        tolerance: number;
+    }
+    class RemoveConsecutiveDuplicateVectorsDto {
+        constructor(vectors?: number[][], checkFirstAndLast?: boolean, tolerance?: number);
+        /**
+         * Vectors array
+         * @default undefined
+         */
+        vectors: number[][];
+        /**
+         * Check first and last vectors
+         * @default false
+         */
+        checkFirstAndLast: boolean;
+        /**
+         * Tolerance value
+         * @default 1e-7
+         * @minimum 0
+         * @maximum Infinity
+         */
+        tolerance: number;
+    }
+    class VectorDto {
+        constructor(vector?: number[]);
+        /**
+         * Vector array of numbers
+         * @default undefined
+         */
+        vector: number[];
+    }
+    class RangeMaxDto {
+        constructor(max?: number);
+        /**
+         * Maximum range boundary
+         * @default 10
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        max: number;
+    }
+    class VectorXYZDto {
+        constructor(x?: number, y?: number, z?: number);
+        /**
+         * X value of vector
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.5
+         */
+        x: number;
+        /**
+         * Y value of vector
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.5
+         */
+        y: number;
+        /**
+         * Z value of vector
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.5
+         */
+        z: number;
+    }
+    class VectorXYDto {
+        constructor(x?: number, y?: number);
+        /**
+         * X value of vector
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.5
+         */
+        x: number;
+        /**
+         * Y value of vector
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.5
+         */
+        y: number;
+    }
+    class SpanDto {
+        constructor(step?: number, min?: number, max?: number);
+        /**
+         * Step of the span
+         * @default 0.1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        step: number;
+        /**
+        * Min value of the span
+        * @default 0
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        min: number;
+        /**
+        * Max value of the span
+        * @default 1
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        max: number;
+    }
+    class SpanEaseItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number, ease?: Math.easeEnum);
+        /**
+         * Nr of items in the span
+         * @default 100
+         * @minimum 2
+         * @maximum Infinity
+         * @step 1
+         */
+        nrItems: number;
+        /**
+        * Min value of the span
+        * @default 0
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        min: number;
+        /**
+        * Max value of the span
+        * @default 1
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        max: number;
+        /**
+        * Ease type
+        * @default easeInSine
+        */
+        ease: Math.easeEnum;
+        /**
+         * Indicates wether only intervals should be outputed. This will output step lengths between the values.
+         * @default false
+         */
+        intervals: boolean;
+    }
+    class SpanLinearItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number);
+        /**
+         * Nr of items in the span
+         * @default 100
+         * @minimum 2
+         * @maximum Infinity
+         * @step 1
+         */
+        nrItems: number;
+        /**
+        * Min value of the span
+        * @default 0
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        min: number;
+        /**
+        * Max value of the span
+        * @default 1
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 1
+        */
+        max: number;
+    }
+    class RayPointDto {
+        constructor(point?: Base.Point3, distance?: number, vector?: number[]);
+        /**
+         * Origin location of the ray
+         * @default undefined
+         */
+        point: Base.Point3;
+        /**
+         * Distance to the point on the ray
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        distance: number;
+        /**
+         * Vector array of numbers
+         * @default undefined
+         */
+        vector: number[];
+    }
+    class VectorsDto {
+        constructor(vectors?: number[][]);
+        /**
+         * Vectors array
+         * @default undefined
+         */
+        vectors: number[][];
+    }
+    class FractionTwoVectorsDto {
+        constructor(fraction?: number, first?: Base.Vector3, second?: Base.Vector3);
+        /**
+         * Fraction number
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        fraction: number;
+        /**
+         * First vector
+         * @default undefined
+         */
+        first: Base.Vector3;
+        /**
+         * Second vector
+         * @default undefined
+         */
+        second: Base.Vector3;
+    }
+    class VectorScalarDto {
+        constructor(scalar?: number, vector?: number[]);
+        /**
+         * Scalar number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        scalar: number;
+        /**
+         * Vector array of numbers
+         * @default undefined
+         */
+        vector: number[];
+    }
+    class TwoVectorsReferenceDto {
+        constructor(reference?: number[], first?: Base.Vector3, second?: Base.Vector3);
+        /**
+         * Reference vector
+         * @default undefined
+         */
+        reference: number[];
+        /**
+         * First vector
+         * @default undefined
+         */
+        first: Base.Vector3;
+        /**
+         * Second vector
+         * @default undefined
+         */
+        second: Base.Vector3;
+    }
+}