@bitbybit-dev/base 0.19.8 → 0.19.9

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

@@ -0,0 +1,521 @@
+export var Point;
+(function (Point) {
+    class PointDto {
+        constructor(point) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+        }
+    }
+    Point.PointDto = PointDto;
+    class PointXYZDto {
+        constructor(x, y, z) {
+            /**
+             * Point
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.x = 0;
+            /**
+             * Point
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.y = 0;
+            /**
+            * Point
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 0.1
+            */
+            this.z = 0;
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+            if (z !== undefined) {
+                this.z = z;
+            }
+        }
+    }
+    Point.PointXYZDto = PointXYZDto;
+    class PointXYDto {
+        constructor(x, y) {
+            /**
+             * Point
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.x = 0;
+            /**
+             * Point
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.y = 0;
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+        }
+    }
+    Point.PointXYDto = PointXYDto;
+    class PointsDto {
+        constructor(points) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+        }
+    }
+    Point.PointsDto = PointsDto;
+    class TwoPointsDto {
+        constructor(point1, point2) {
+            if (point1 !== undefined) {
+                this.point1 = point1;
+            }
+            if (point2 !== undefined) {
+                this.point2 = point2;
+            }
+        }
+    }
+    Point.TwoPointsDto = TwoPointsDto;
+    class DrawPointDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(point, opacity, size, colours, updatable, pointMesh) {
+            /**
+             * Value between 0 and 1
+             * @default 1
+             * @minimum 0
+             * @maximum 1
+             * @step 0.1
+             */
+            this.opacity = 1;
+            /**
+             * Size of the point
+             * @default 3
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.size = 3;
+            /**
+             * Hex colour string
+             * @default #444444
+             */
+            this.colours = "#444444";
+            /**
+             * Indicates wether the position of this point will change in time
+             * @default false
+             */
+            this.updatable = false;
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (opacity !== undefined) {
+                this.opacity = opacity;
+            }
+            if (size !== undefined) {
+                this.size = size;
+            }
+            if (colours !== undefined) {
+                this.colours = colours;
+            }
+            if (updatable !== undefined) {
+                this.updatable = updatable;
+            }
+            if (pointMesh !== undefined) {
+                this.pointMesh = pointMesh;
+            }
+        }
+    }
+    Point.DrawPointDto = DrawPointDto;
+    class DrawPointsDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(points, opacity, size, colours, updatable, pointsMesh) {
+            /**
+             * Value between 0 and 1
+             * @default 1
+             * @minimum 0
+             * @maximum 1
+             * @step 0.1
+             */
+            this.opacity = 1;
+            /**
+             * Size of the points
+             * @default 0.1
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.size = 0.1;
+            /**
+             * Hex colour string or collection of strings
+             * @default #444444
+             */
+            this.colours = "#444444";
+            /**
+             * Indicates wether the position of this point will change in time
+             * @default false
+             */
+            this.updatable = false;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (opacity !== undefined) {
+                this.opacity = opacity;
+            }
+            if (size !== undefined) {
+                this.size = size;
+            }
+            if (colours !== undefined) {
+                this.colours = colours;
+            }
+            if (updatable !== undefined) {
+                this.updatable = updatable;
+            }
+            if (pointsMesh !== undefined) {
+                this.pointsMesh = pointsMesh;
+            }
+        }
+    }
+    Point.DrawPointsDto = DrawPointsDto;
+    class TransformPointDto {
+        constructor(point, transformation) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Point.TransformPointDto = TransformPointDto;
+    class TransformPointsDto {
+        constructor(points, transformation) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Point.TransformPointsDto = TransformPointsDto;
+    class TranslatePointsWithVectorsDto {
+        constructor(points, translations) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (translations !== undefined) {
+                this.translations = translations;
+            }
+        }
+    }
+    Point.TranslatePointsWithVectorsDto = TranslatePointsWithVectorsDto;
+    class TranslatePointsDto {
+        constructor(points, translation) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (translation !== undefined) {
+                this.translation = translation;
+            }
+        }
+    }
+    Point.TranslatePointsDto = TranslatePointsDto;
+    class TranslateXYZPointsDto {
+        constructor(points, x, y, z) {
+            /**
+             * X vector value
+             * @default 0
+             */
+            this.x = 0;
+            /**
+            * Y vector value
+            * @default 1
+            */
+            this.y = 1;
+            /**
+            * Z vector value
+            * @default 0
+            */
+            this.z = 0;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+            if (z !== undefined) {
+                this.z = z;
+            }
+        }
+    }
+    Point.TranslateXYZPointsDto = TranslateXYZPointsDto;
+    class ScalePointsCenterXYZDto {
+        constructor(points, 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 (points !== undefined) {
+                this.points = points;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (scaleXyz !== undefined) {
+                this.scaleXyz = scaleXyz;
+            }
+        }
+    }
+    Point.ScalePointsCenterXYZDto = ScalePointsCenterXYZDto;
+    class RotatePointsCenterAxisDto {
+        constructor(points, 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 (points !== undefined) {
+                this.points = points;
+            }
+            if (angle !== undefined) {
+                this.angle = angle;
+            }
+            if (axis !== undefined) {
+                this.axis = axis;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+        }
+    }
+    Point.RotatePointsCenterAxisDto = RotatePointsCenterAxisDto;
+    class TransformsForPointsDto {
+        constructor(points, transformation) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (transformation !== undefined) {
+                this.transformation = transformation;
+            }
+        }
+    }
+    Point.TransformsForPointsDto = TransformsForPointsDto;
+    class RemoveConsecutiveDuplicatesDto {
+        constructor(points, tolerance, checkFirstAndLast) {
+            /**
+             * Tolerance for removing duplicates
+             * @default 1e-7
+             * @minimum 0
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            /**
+             * Check first and last point for duplicates
+             */
+            this.checkFirstAndLast = false;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+            if (checkFirstAndLast !== undefined) {
+                this.checkFirstAndLast = checkFirstAndLast;
+            }
+        }
+    }
+    Point.RemoveConsecutiveDuplicatesDto = RemoveConsecutiveDuplicatesDto;
+    class ClosestPointFromPointsDto {
+        constructor(points, point) {
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (point !== undefined) {
+                this.point = point;
+            }
+        }
+    }
+    Point.ClosestPointFromPointsDto = ClosestPointFromPointsDto;
+    class StartEndPointsDto {
+        constructor(startPoint, endPoint) {
+            if (startPoint !== undefined) {
+                this.startPoint = startPoint;
+            }
+            if (endPoint !== undefined) {
+                this.endPoint = endPoint;
+            }
+        }
+    }
+    Point.StartEndPointsDto = StartEndPointsDto;
+    class StartEndPointsListDto {
+        constructor(startPoint, endPoints) {
+            if (startPoint !== undefined) {
+                this.startPoint = startPoint;
+            }
+            if (endPoints !== undefined) {
+                this.endPoints = endPoints;
+            }
+        }
+    }
+    Point.StartEndPointsListDto = StartEndPointsListDto;
+    class MultiplyPointDto {
+        constructor(point, amountOfPoints) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (amountOfPoints !== undefined) {
+                this.amountOfPoints = amountOfPoints;
+            }
+        }
+    }
+    Point.MultiplyPointDto = MultiplyPointDto;
+    class SpiralDto {
+        constructor(radius, numberPoints, widening, factor, phi) {
+            /**
+             * Identifies phi angle
+             * @default 0.9
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.phi = 0.9;
+            /**
+             * Identifies how many points will be created
+             * @default 200
+             * @minimum 0
+             * @maximum Infinity
+             * @step 10
+             */
+            this.numberPoints = 200;
+            /**
+             * Widening factor of the spiral
+             * @default 3
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.widening = 3;
+            /**
+             * Radius of the spiral
+             * @default 6
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.radius = 6;
+            /**
+             * Factor of the spiral
+             * @default 1
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.factor = 1;
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+            if (numberPoints !== undefined) {
+                this.numberPoints = numberPoints;
+            }
+            if (widening !== undefined) {
+                this.widening = widening;
+            }
+            if (factor !== undefined) {
+                this.factor = factor;
+            }
+            if (phi !== undefined) {
+                this.phi = phi;
+            }
+        }
+    }
+    Point.SpiralDto = SpiralDto;
+    class HexGridCentersDto {
+        constructor(nrHexagonsX, nrHexagonsY, radiusHexagon, orientOnCenter, pointsOnGround) {
+            /**
+             * Number of hexagons on Y direction
+             * @default 21
+             * @minimum 0
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrHexagonsY = 21;
+            /**
+             * Number of Hexagons on Z direction
+             * @default 21
+             * @minimum 0
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrHexagonsX = 21;
+            /**
+             * Orient hexagon points grid on center
+             * @default false
+             */
+            this.orientOnCenter = false;
+            /**
+             * Orient points on the ground
+             * @default false
+             */
+            this.pointsOnGround = false;
+            if (nrHexagonsX !== undefined) {
+                this.nrHexagonsX = nrHexagonsX;
+            }
+            if (nrHexagonsY !== undefined) {
+                this.nrHexagonsY = nrHexagonsY;
+            }
+            if (radiusHexagon !== undefined) {
+                this.radiusHexagon = radiusHexagon;
+            }
+            if (orientOnCenter !== undefined) {
+                this.orientOnCenter = orientOnCenter;
+            }
+            if (pointsOnGround !== undefined) {
+                this.pointsOnGround = pointsOnGround;
+            }
+        }
+    }
+    Point.HexGridCentersDto = HexGridCentersDto;
+})(Point || (Point = {}));

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

@@ -0,0 +1,83 @@
+export declare namespace Text {
+    class TextDto {
+        constructor(text?: string);
+        /**
+         * The text
+         * @default Hello World
+         */
+        text: string;
+    }
+    class TextSplitDto {
+        constructor(text?: string, separator?: string);
+        /**
+         * Text to split
+         * @default a,b,c
+         */
+        text: string;
+        /**
+         * Text to split by
+         * @default ,
+         */
+        separator: string;
+    }
+    class TextReplaceDto {
+        constructor(text?: string, search?: string, replaceWith?: string);
+        /**
+         * Text to replace
+         * @default a-c
+         */
+        text: string;
+        /**
+         * Text to search for
+         * @default -
+         */
+        search: string;
+        /**
+         * Text to replace found occurences
+         * @default b
+         */
+        replaceWith: string;
+    }
+    class TextJoinDto {
+        constructor(list?: string[], separator?: string);
+        /**
+         * Text to join
+         * @default undefined
+         */
+        list: string[];
+        /**
+         * Text to join by
+         * @default ,
+         */
+        separator: string;
+    }
+    class ToStringDto<T> {
+        constructor(item?: T);
+        /**
+         * Item to stringify
+         * @default undefined
+         */
+        item: T;
+    }
+    class ToStringEachDto<T> {
+        constructor(list?: T[]);
+        /**
+         * Item to stringify
+         * @default undefined
+         */
+        list: T[];
+    }
+    class TextFormatDto {
+        constructor(text?: string, values?: string[]);
+        /**
+         * Text to format
+         * @default Hello {0}
+         */
+        text: string;
+        /**
+         * Values to format
+         * @default ["World"]
+         */
+        values: string[];
+    }
+}

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

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+export var Text;
+(function (Text) {
+    class TextDto {
+        constructor(text) {
+            /**
+             * The text
+             * @default Hello World
+             */
+            this.text = "Hello World";
+            if (text !== undefined) {
+                this.text = text;
+            }
+        }
+    }
+    Text.TextDto = TextDto;
+    class TextSplitDto {
+        constructor(text, separator) {
+            /**
+             * Text to split
+             * @default a,b,c
+             */
+            this.text = "a,b,c";
+            /**
+             * Text to split by
+             * @default ,
+             */
+            this.separator = ",";
+            if (text !== undefined) {
+                this.text = text;
+            }
+            if (separator !== undefined) {
+                this.separator = separator;
+            }
+        }
+    }
+    Text.TextSplitDto = TextSplitDto;
+    class TextReplaceDto {
+        constructor(text, search, replaceWith) {
+            /**
+             * Text to replace
+             * @default a-c
+             */
+            this.text = "a-c";
+            /**
+             * Text to search for
+             * @default -
+             */
+            this.search = "-";
+            /**
+             * Text to replace found occurences
+             * @default b
+             */
+            this.replaceWith = "b";
+            if (text !== undefined) {
+                this.text = text;
+            }
+            if (search !== undefined) {
+                this.search = search;
+            }
+            if (replaceWith !== undefined) {
+                this.replaceWith = replaceWith;
+            }
+        }
+    }
+    Text.TextReplaceDto = TextReplaceDto;
+    class TextJoinDto {
+        constructor(list, separator) {
+            /**
+             * Text to join by
+             * @default ,
+             */
+            this.separator = ",";
+            if (list !== undefined) {
+                this.list = list;
+            }
+            if (separator !== undefined) {
+                this.separator = separator;
+            }
+        }
+    }
+    Text.TextJoinDto = TextJoinDto;
+    class ToStringDto {
+        constructor(item) {
+            if (item !== undefined) {
+                this.item = item;
+            }
+        }
+    }
+    Text.ToStringDto = ToStringDto;
+    class ToStringEachDto {
+        constructor(list) {
+            if (list !== undefined) {
+                this.list = list;
+            }
+        }
+    }
+    Text.ToStringEachDto = ToStringEachDto;
+    class TextFormatDto {
+        constructor(text, values) {
+            /**
+             * Text to format
+             * @default Hello {0}
+             */
+            this.text = "Hello {0}";
+            /**
+             * Values to format
+             * @default ["World"]
+             */
+            this.values = ["World"];
+            if (text !== undefined) {
+                this.text = text;
+            }
+            if (values !== undefined) {
+                this.values = values;
+            }
+        }
+    }
+    Text.TextFormatDto = TextFormatDto;
+})(Text || (Text = {}));