@bitbybit-dev/base 0.19.8 → 0.19.9

package/lib/api/inputs/{vector-inputs.ts → vector-inputs.d.ts}

@@ -1,14 +1,8 @@
-/* eslint-disable @typescript-eslint/no-namespace */
 import { Base } from "./base-inputs";
 import { Math } from "./inputs";
-
-export namespace Vector {
-
-    export class TwoVectorsDto {
-        constructor(first?: number[], second?: number[]) {
-            if (first !== undefined) { this.first = first; }
-            if (second !== undefined) { this.second = second; }
-        }
+export declare namespace Vector {
+    class TwoVectorsDto {
+        constructor(first?: number[], second?: number[]);
         /**
          * First vector
          * @default undefined
@@ -20,21 +14,16 @@ export namespace Vector {
          */
         second: number[];
     }
-    export class VectorBoolDto {
-        constructor(vector?: boolean[]) {
-            if (vector !== undefined) { this.vector = vector; }
-        }
+    class VectorBoolDto {
+        constructor(vector?: boolean[]);
         /**
          * Vector of booleans
          * @default undefined
          */
         vector: boolean[];
     }
-    export class RemoveAllDuplicateVectorsDto {
-        constructor(vectors?: number[][], tolerance?: number) {
-            if (vectors !== undefined) { this.vectors = vectors; }
-            if (tolerance !== undefined) { this.tolerance = tolerance; }
-        }
+    class RemoveAllDuplicateVectorsDto {
+        constructor(vectors?: number[][], tolerance?: number);
         /**
          * Vectors array
          * @default undefined
@@ -46,14 +35,10 @@ export namespace Vector {
          * @minimum 0
          * @maximum Infinity
          */
-        tolerance = 1e-7;
+        tolerance: number;
     }
-    export class RemoveConsecutiveDuplicateVectorsDto {
-        constructor(vectors?: number[][], checkFirstAndLast?: boolean, tolerance?: number) {
-            if (vectors !== undefined) { this.vectors = vectors; }
-            if (checkFirstAndLast !== undefined) { this.checkFirstAndLast = checkFirstAndLast; }
-            if (tolerance !== undefined) { this.tolerance = tolerance; }
-        }
+    class RemoveConsecutiveDuplicateVectorsDto {
+        constructor(vectors?: number[][], checkFirstAndLast?: boolean, tolerance?: number);
         /**
          * Vectors array
          * @default undefined
@@ -63,29 +48,25 @@ export namespace Vector {
          * Check first and last vectors
          * @default false
          */
-        checkFirstAndLast = false;
+        checkFirstAndLast: boolean;
         /**
          * Tolerance value
          * @default 1e-7
          * @minimum 0
          * @maximum Infinity
          */
-        tolerance = 1e-7;
+        tolerance: number;
     }
-    export class VectorDto {
-        constructor(vector?: number[]) {
-            if (vector !== undefined) { this.vector = vector; }
-        }
+    class VectorDto {
+        constructor(vector?: number[]);
         /**
          * Vector array of numbers
          * @default undefined
          */
         vector: number[];
     }
-    export class RangeMaxDto {
-        constructor(max?: number) {
-            if (max !== undefined) { this.max = max; }
-        }
+    class RangeMaxDto {
+        constructor(max?: number);
         /**
          * Maximum range boundary
          * @default 10
@@ -95,12 +76,8 @@ export namespace Vector {
          */
         max: number;
     }
-    export class VectorXYZDto {
-        constructor(x?: number, y?: number, z?: number) {
-            if (x !== undefined) { this.x = x; }
-            if (y !== undefined) { this.y = y; }
-            if (z !== undefined) { this.z = z; }
-        }
+    class VectorXYZDto {
+        constructor(x?: number, y?: number, z?: number);
         /**
          * X value of vector
          * @default 0
@@ -126,11 +103,8 @@ export namespace Vector {
          */
         z: number;
     }
-    export class VectorXYDto {
-        constructor(x?: number, y?: number) {
-            if (x !== undefined) { this.x = x; }
-            if (y !== undefined) { this.y = y; }
-        }
+    class VectorXYDto {
+        constructor(x?: number, y?: number);
         /**
          * X value of vector
          * @default 0
@@ -148,12 +122,8 @@ export namespace Vector {
          */
         y: number;
     }
-    export class SpanDto {
-        constructor(step?: number, min?: number, max?: number) {
-            if (step !== undefined) { this.step = step; }
-            if (min !== undefined) { this.min = min; }
-            if (max !== undefined) { this.max = max; }
-        }
+    class SpanDto {
+        constructor(step?: number, min?: number, max?: number);
         /**
          * Step of the span
          * @default 0.1
@@ -161,7 +131,7 @@ export namespace Vector {
          * @maximum Infinity
          * @step 0.1
          */
-        step = 0.1;
+        step: number;
         /**
         * Min value of the span
         * @default 0
@@ -169,7 +139,7 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min = 0;
+        min: number;
         /**
         * Max value of the span
         * @default 1
@@ -177,15 +147,10 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max = 1;
+        max: number;
     }
-    export class SpanEaseItemsDto {
-        constructor(nrItems?: number, min?: number, max?: number, ease?: Math.easeEnum) {
-            if (nrItems !== undefined) { this.nrItems = nrItems; }
-            if (min !== undefined) { this.min = min; }
-            if (max !== undefined) { this.max = max; }
-            if (ease !== undefined) { this.ease = ease; }
-        }
+    class SpanEaseItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number, ease?: Math.easeEnum);
         /**
          * Nr of items in the span
          * @default 100
@@ -193,7 +158,7 @@ export namespace Vector {
          * @maximum Infinity
          * @step 1
          */
-        nrItems = 100;
+        nrItems: number;
         /**
         * Min value of the span
         * @default 0
@@ -201,7 +166,7 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min = 0;
+        min: number;
         /**
         * Max value of the span
         * @default 1
@@ -209,24 +174,20 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max = 1;
+        max: number;
         /**
         * Ease type
         * @default easeInSine
         */
-        ease: Math.easeEnum = Math.easeEnum.easeInSine;
+        ease: Math.easeEnum;
         /**
          * Indicates wether only intervals should be outputed. This will output step lengths between the values.
          * @default false
          */
-        intervals = false;
+        intervals: boolean;
     }
-    export class SpanLinearItemsDto {
-        constructor(nrItems?: number, min?: number, max?: number) {
-            if (nrItems !== undefined) { this.nrItems = nrItems; }
-            if (min !== undefined) { this.min = min; }
-            if (max !== undefined) { this.max = max; }
-        }
+    class SpanLinearItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number);
         /**
          * Nr of items in the span
          * @default 100
@@ -234,7 +195,7 @@ export namespace Vector {
          * @maximum Infinity
          * @step 1
          */
-        nrItems = 100;
+        nrItems: number;
         /**
         * Min value of the span
         * @default 0
@@ -242,7 +203,7 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min = 0;
+        min: number;
         /**
         * Max value of the span
         * @default 1
@@ -250,14 +211,10 @@ export namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max = 1;
+        max: number;
     }
-    export class RayPointDto {
-        constructor(point?: Base.Point3, distance?: number, vector?: number[]) {
-            if (point !== undefined) { this.point = point; }
-            if (distance !== undefined) { this.distance = distance; }
-            if (vector !== undefined) { this.vector = vector; }
-        }
+    class RayPointDto {
+        constructor(point?: Base.Point3, distance?: number, vector?: number[]);
         /**
          * Origin location of the ray
          * @default undefined
@@ -277,22 +234,16 @@ export namespace Vector {
          */
         vector: number[];
     }
-    export class VectorsDto {
-        constructor(vectors?: number[][]) {
-            if (vectors !== undefined) { this.vectors = vectors; }
-        }
+    class VectorsDto {
+        constructor(vectors?: number[][]);
         /**
          * Vectors array
          * @default undefined
          */
         vectors: number[][];
     }
-    export class FractionTwoVectorsDto {
-        constructor(fraction?: number, first?: Base.Vector3, second?: Base.Vector3) {
-            if (fraction !== undefined) { this.fraction = fraction; }
-            if (first !== undefined) { this.first = first; }
-            if (second !== undefined) { this.second = second; }
-        }
+    class FractionTwoVectorsDto {
+        constructor(fraction?: number, first?: Base.Vector3, second?: Base.Vector3);
         /**
          * Fraction number
          * @default 0.5
@@ -300,7 +251,7 @@ export namespace Vector {
          * @maximum Infinity
          * @step 0.1
          */
-        fraction = 0.5;
+        fraction: number;
         /**
          * First vector
          * @default undefined
@@ -312,11 +263,8 @@ export namespace Vector {
          */
         second: Base.Vector3;
     }
-    export class VectorScalarDto {
-        constructor(scalar?: number, vector?: number[]) {
-            if (scalar !== undefined) { this.scalar = scalar; }
-            if (vector !== undefined) { this.vector = vector; }
-        }
+    class VectorScalarDto {
+        constructor(scalar?: number, vector?: number[]);
         /**
          * Scalar number
          * @default 1
@@ -331,12 +279,8 @@ export namespace Vector {
          */
         vector: number[];
     }
-    export class TwoVectorsReferenceDto {
-        constructor(reference?: number[], first?: Base.Vector3, second?: Base.Vector3) {
-            if (reference !== undefined) { this.reference = reference; }
-            if (first !== undefined) { this.first = first; }
-            if (second !== undefined) { this.second = second; }
-        }
+    class TwoVectorsReferenceDto {
+        constructor(reference?: number[], first?: Base.Vector3, second?: Base.Vector3);
         /**
          * Reference vector
          * @default undefined

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

@@ -0,0 +1,304 @@
+import { Math } from "./inputs";
+export var Vector;
+(function (Vector) {
+    class TwoVectorsDto {
+        constructor(first, second) {
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.TwoVectorsDto = TwoVectorsDto;
+    class VectorBoolDto {
+        constructor(vector) {
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorBoolDto = VectorBoolDto;
+    class RemoveAllDuplicateVectorsDto {
+        constructor(vectors, tolerance) {
+            /**
+             * Tolerance value
+             * @default 1e-7
+             * @minimum 0
+             * @maximum Infinity
+             */
+            this.tolerance = 1e-7;
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Vector.RemoveAllDuplicateVectorsDto = RemoveAllDuplicateVectorsDto;
+    class RemoveConsecutiveDuplicateVectorsDto {
+        constructor(vectors, checkFirstAndLast, tolerance) {
+            /**
+             * Check first and last vectors
+             * @default false
+             */
+            this.checkFirstAndLast = false;
+            /**
+             * Tolerance value
+             * @default 1e-7
+             * @minimum 0
+             * @maximum Infinity
+             */
+            this.tolerance = 1e-7;
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+            if (checkFirstAndLast !== undefined) {
+                this.checkFirstAndLast = checkFirstAndLast;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Vector.RemoveConsecutiveDuplicateVectorsDto = RemoveConsecutiveDuplicateVectorsDto;
+    class VectorDto {
+        constructor(vector) {
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorDto = VectorDto;
+    class RangeMaxDto {
+        constructor(max) {
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.RangeMaxDto = RangeMaxDto;
+    class VectorXYZDto {
+        constructor(x, y, z) {
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+            if (z !== undefined) {
+                this.z = z;
+            }
+        }
+    }
+    Vector.VectorXYZDto = VectorXYZDto;
+    class VectorXYDto {
+        constructor(x, y) {
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+        }
+    }
+    Vector.VectorXYDto = VectorXYDto;
+    class SpanDto {
+        constructor(step, min, max) {
+            /**
+             * Step of the span
+             * @default 0.1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.step = 0.1;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            if (step !== undefined) {
+                this.step = step;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.SpanDto = SpanDto;
+    class SpanEaseItemsDto {
+        constructor(nrItems, min, max, ease) {
+            /**
+             * Nr of items in the span
+             * @default 100
+             * @minimum 2
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrItems = 100;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            /**
+            * Ease type
+            * @default easeInSine
+            */
+            this.ease = Math.easeEnum.easeInSine;
+            /**
+             * Indicates wether only intervals should be outputed. This will output step lengths between the values.
+             * @default false
+             */
+            this.intervals = false;
+            if (nrItems !== undefined) {
+                this.nrItems = nrItems;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+            if (ease !== undefined) {
+                this.ease = ease;
+            }
+        }
+    }
+    Vector.SpanEaseItemsDto = SpanEaseItemsDto;
+    class SpanLinearItemsDto {
+        constructor(nrItems, min, max) {
+            /**
+             * Nr of items in the span
+             * @default 100
+             * @minimum 2
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrItems = 100;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            if (nrItems !== undefined) {
+                this.nrItems = nrItems;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.SpanLinearItemsDto = SpanLinearItemsDto;
+    class RayPointDto {
+        constructor(point, distance, vector) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (distance !== undefined) {
+                this.distance = distance;
+            }
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.RayPointDto = RayPointDto;
+    class VectorsDto {
+        constructor(vectors) {
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+        }
+    }
+    Vector.VectorsDto = VectorsDto;
+    class FractionTwoVectorsDto {
+        constructor(fraction, first, second) {
+            /**
+             * Fraction number
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.fraction = 0.5;
+            if (fraction !== undefined) {
+                this.fraction = fraction;
+            }
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.FractionTwoVectorsDto = FractionTwoVectorsDto;
+    class VectorScalarDto {
+        constructor(scalar, vector) {
+            if (scalar !== undefined) {
+                this.scalar = scalar;
+            }
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorScalarDto = VectorScalarDto;
+    class TwoVectorsReferenceDto {
+        constructor(reference, first, second) {
+            if (reference !== undefined) {
+                this.reference = reference;
+            }
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.TwoVectorsReferenceDto = TwoVectorsReferenceDto;
+})(Vector || (Vector = {}));