@bitbybit-dev/base 0.20.12 → 0.20.14

package/lib/api/GlobalCDNProvider.js

@@ -1,3 +1,3 @@
 export class GlobalCDNProvider {
 }
-GlobalCDNProvider.BITBYBIT_CDN_URL = "https://cdn.jsdelivr.net/gh/bitbybit-dev/bitbybit-assets@0.20.12";
+GlobalCDNProvider.BITBYBIT_CDN_URL = "https://cdn.jsdelivr.net/gh/bitbybit-dev/bitbybit-assets@0.20.14";

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

@@ -475,4 +475,43 @@ export declare namespace Lists {
          */
         clone?: boolean;
     }
+    class ConcatenateDto<T> {
+        constructor(lists?: T[][], clone?: boolean);
+        /**
+         * The lists to concatenate
+         * @default undefined
+         */
+        lists: T[][];
+        /**
+         * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
+         * @default true
+         */
+        clone?: boolean;
+    }
+    class IncludesDto<T> {
+        constructor(list?: T[], item?: T);
+        /**
+         * The list to check
+         * @default undefined
+         */
+        list: T[];
+        /**
+         * The item to look for
+         * @default undefined
+         */
+        item: T;
+    }
+    class InterleaveDto<T> {
+        constructor(lists?: T[][], clone?: boolean);
+        /**
+         * The lists to interleave
+         * @default undefined
+         */
+        lists: T[][];
+        /**
+         * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
+         * @default true
+         */
+        clone?: boolean;
+    }
 }

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

@@ -573,4 +573,47 @@ export var Lists;
         }
     }
     Lists.AddItemFirstLastDto = AddItemFirstLastDto;
+    class ConcatenateDto {
+        constructor(lists, clone) {
+            /**
+             * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
+             * @default true
+             */
+            this.clone = true;
+            if (lists !== undefined) {
+                this.lists = lists;
+            }
+            if (clone !== undefined) {
+                this.clone = clone;
+            }
+        }
+    }
+    Lists.ConcatenateDto = ConcatenateDto;
+    class IncludesDto {
+        constructor(list, item) {
+            if (list !== undefined) {
+                this.list = list;
+            }
+            if (item !== undefined) {
+                this.item = item;
+            }
+        }
+    }
+    Lists.IncludesDto = IncludesDto;
+    class InterleaveDto {
+        constructor(lists, clone) {
+            /**
+             * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
+             * @default true
+             */
+            this.clone = true;
+            if (lists !== undefined) {
+                this.lists = lists;
+            }
+            if (clone !== undefined) {
+                this.clone = clone;
+            }
+        }
+    }
+    Lists.InterleaveDto = InterleaveDto;
 })(Lists || (Lists = {}));

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

@@ -308,4 +308,158 @@ export declare namespace Math {
          */
         decimalPlaces: number;
     }
+    class ClampDto {
+        constructor(number?: number, min?: number, max?: number);
+        /**
+         * Number to clamp
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Minimum value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        min: number;
+        /**
+         * Maximum value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        max: number;
+    }
+    class LerpDto {
+        constructor(start?: number, end?: number, t?: number);
+        /**
+         * Start value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        start: number;
+        /**
+         * End value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        end: number;
+        /**
+         * Interpolation value (0-1)
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.01
+         */
+        t: number;
+    }
+    class InverseLerpDto {
+        constructor(start?: number, end?: number, value?: number);
+        /**
+         * Start value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        start: number;
+        /**
+         * End value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        end: number;
+        /**
+         * Value to find t for
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        value: number;
+    }
+    class WrapDto {
+        constructor(number?: number, min?: number, max?: number);
+        /**
+         * Number to wrap
+         * @default 1.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Minimum value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        min: number;
+        /**
+         * Maximum value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        max: number;
+    }
+    class PingPongDto {
+        constructor(t?: number, length?: number);
+        /**
+         * Time value
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        t: number;
+        /**
+         * Length of ping pong
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        length: number;
+    }
+    class MoveTowardsDto {
+        constructor(current?: number, target?: number, maxDelta?: number);
+        /**
+         * Current value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        current: number;
+        /**
+         * Target value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        target: number;
+        /**
+         * Maximum change amount
+         * @default 0.1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.01
+         */
+        maxDelta: number;
+    }
 }

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

@@ -388,4 +388,221 @@ export var Math;
         }
     }
     Math.ToFixedDto = ToFixedDto;
+    class ClampDto {
+        constructor(number, min, max) {
+            /**
+             * Number to clamp
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.number = 0.5;
+            /**
+             * Minimum value
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.min = 0;
+            /**
+             * Maximum value
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.max = 1;
+            if (number !== undefined) {
+                this.number = number;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Math.ClampDto = ClampDto;
+    class LerpDto {
+        constructor(start, end, t) {
+            /**
+             * Start value
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.start = 0;
+            /**
+             * End value
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.end = 1;
+            /**
+             * Interpolation value (0-1)
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.01
+             */
+            this.t = 0.5;
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (t !== undefined) {
+                this.t = t;
+            }
+        }
+    }
+    Math.LerpDto = LerpDto;
+    class InverseLerpDto {
+        constructor(start, end, value) {
+            /**
+             * Start value
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.start = 0;
+            /**
+             * End value
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.end = 1;
+            /**
+             * Value to find t for
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.value = 0.5;
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (value !== undefined) {
+                this.value = value;
+            }
+        }
+    }
+    Math.InverseLerpDto = InverseLerpDto;
+    class WrapDto {
+        constructor(number, min, max) {
+            /**
+             * Number to wrap
+             * @default 1.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.number = 1.5;
+            /**
+             * Minimum value
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.min = 0;
+            /**
+             * Maximum value
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.max = 1;
+            if (number !== undefined) {
+                this.number = number;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Math.WrapDto = WrapDto;
+    class PingPongDto {
+        constructor(t, length) {
+            /**
+             * Time value
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.t = 0.5;
+            /**
+             * Length of ping pong
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.length = 1;
+            if (t !== undefined) {
+                this.t = t;
+            }
+            if (length !== undefined) {
+                this.length = length;
+            }
+        }
+    }
+    Math.PingPongDto = PingPongDto;
+    class MoveTowardsDto {
+        constructor(current, target, maxDelta) {
+            /**
+             * Current value
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.current = 0;
+            /**
+             * Target value
+             * @default 1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.target = 1;
+            /**
+             * Maximum change amount
+             * @default 0.1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.01
+             */
+            this.maxDelta = 0.1;
+            if (current !== undefined) {
+                this.current = current;
+            }
+            if (target !== undefined) {
+                this.target = target;
+            }
+            if (maxDelta !== undefined) {
+                this.maxDelta = maxDelta;
+            }
+        }
+    }
+    Math.MoveTowardsDto = MoveTowardsDto;
 })(Math || (Math = {}));

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

@@ -81,6 +81,145 @@ export declare namespace Text {
          */
         values: string[];
     }
+    class TextSearchDto {
+        constructor(text?: string, search?: string);
+        /**
+         * Text to search in
+         * @default hello world
+         */
+        text: string;
+        /**
+         * Text to search for
+         * @default world
+         */
+        search: string;
+    }
+    class TextSubstringDto {
+        constructor(text?: string, start?: number, end?: number);
+        /**
+         * Text to extract from
+         * @default hello world
+         */
+        text: string;
+        /**
+         * Start index
+         * @default 0
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        start: number;
+        /**
+         * End index
+         * @default 5
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        end?: number;
+    }
+    class TextIndexDto {
+        constructor(text?: string, index?: number);
+        /**
+         * Text to get character from
+         * @default hello
+         */
+        text: string;
+        /**
+         * Index of character
+         * @default 0
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        index: number;
+    }
+    class TextPadDto {
+        constructor(text?: string, length?: number, padString?: string);
+        /**
+         * Text to pad
+         * @default x
+         */
+        text: string;
+        /**
+         * Target length
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        length: number;
+        /**
+         * String to pad with
+         * @default a
+         */
+        padString: string;
+    }
+    class TextRepeatDto {
+        constructor(text?: string, count?: number);
+        /**
+         * Text to repeat
+         * @default ha
+         */
+        text: string;
+        /**
+         * Number of repetitions
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        count: number;
+    }
+    class TextConcatDto {
+        constructor(texts?: string[]);
+        /**
+         * Texts to concatenate
+         * @default ["hello", " ", "world"]
+         */
+        texts: string[];
+    }
+    class TextRegexDto {
+        constructor(text?: string, pattern?: string, flags?: string);
+        /**
+         * Text to search in
+         * @default hello123world
+         */
+        text: string;
+        /**
+         * Regular expression pattern
+         * @default [0-9]+
+         */
+        pattern: string;
+        /**
+         * Regular expression flags (g, i, m, s, u, y)
+         * @default g
+         */
+        flags: string;
+    }
+    class TextRegexReplaceDto {
+        constructor(text?: string, pattern?: string, flags?: string, replaceWith?: string);
+        /**
+         * Text to search in
+         * @default hello123world456
+         */
+        text: string;
+        /**
+         * Regular expression pattern
+         * @default [0-9]+
+         */
+        pattern: string;
+        /**
+         * Regular expression flags (g, i, m, s, u, y)
+         * @default g
+         */
+        flags: string;
+        /**
+         * Text to replace matches with
+         * @default X
+         */
+        replaceWith: string;
+    }
     class VectorCharDto {
         constructor(char?: string, xOffset?: number, yOffset?: number, height?: number, extrudeOffset?: number);
         /**