@vandenberghinc/volt 1.1.2

package/frontend/dist/modules/colors.d.ts

@@ -0,0 +1,26 @@
+interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+type ColorObject = Record<'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white', string>;
+declare const Colors: any;
+export { Colors };
+type Hex = string;
+type RGBArray = number[];
+interface RGBObject {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare class ColorRangeClass {
+    start: RGBObject;
+    end: RGBObject;
+    constructor(start: Hex | RGBArray, end: Hex | RGBArray);
+    array_to_rgba(array: RGBArray): RGBObject;
+    interpolate(percent?: number, alpha?: number): Hex;
+}
+export declare const ColorRange: <Extensions extends object = {}>(start: string | RGBArray, end: string | RGBArray) => ColorRangeClass & Extensions;
+export declare const NullColorRange: <Extensions extends object = {}>() => ColorRangeClass & Extensions;

package/frontend/dist/modules/colors.js

@@ -0,0 +1,340 @@
+// Colors module
+const Colors = {
+    // ---------------------------------------------------------
+    // Attributes.
+    black: "\u001b[30m",
+    red: "\u001b[31m",
+    red_bold: "\u001b[31m\u001b[1m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    blue: "\u001b[34m",
+    magenta: "\u001b[35m",
+    cyan: "\u001b[36m",
+    light_gray: "\u001b[37m",
+    gray: "\u001b[90m",
+    bold: "\u001b[1m",
+    italic: "\u001b[3m",
+    end: "\u001b[0m",
+    purple: "\u001b[94m",
+    bg: {
+        black: "\u001b[40m",
+        red: "\u001b[41m",
+        green: "\u001b[42m",
+        yellow: "\u001b[43m",
+        blue: "\u001b[44m",
+        magenta: "\u001b[45m",
+        cyan: "\u001b[46m",
+        white: "\u001b[47m",
+    },
+    bright_bg: {
+        black: "\u001b[100m",
+        red: "\u001b[101m",
+        green: "\u001b[102m",
+        yellow: "\u001b[103m",
+        blue: "\u001b[104m",
+        magenta: "\u001b[105m",
+        cyan: "\u001b[106m",
+        white: "\u001b[107m",
+    },
+    // Hex module
+    hex: {
+        // Get the brightness of a hex color (0.0 white, 1.0 dark)
+        get_brightness(color) {
+            color = color.replace(/^#/, '');
+            const bigint = parseInt(color, 16);
+            const r = (bigint >> 16) & 255;
+            const g = (bigint >> 8) & 255;
+            const b = bigint & 255;
+            const brightness = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+            return brightness;
+        },
+        // Convert hex to RGBA
+        to_rgb(hex, as_array = false) {
+            const index = hex.indexOf("#");
+            if (index !== -1) {
+                hex = hex.substr(index + 1);
+            }
+            let r = parseInt(hex.substring(0, 2), 16);
+            let g = parseInt(hex.substring(2, 4), 16);
+            let b = parseInt(hex.substring(4, 6), 16);
+            let a = 1;
+            if (hex.length > 6) {
+                a = parseInt(hex.substring(6, 8), 16) / 255;
+            }
+            if (isNaN(r)) {
+                r = 0;
+            }
+            if (isNaN(g)) {
+                g = 0;
+            }
+            if (isNaN(b)) {
+                b = 0;
+            }
+            if (isNaN(a)) {
+                a = 1;
+            }
+            if (as_array) {
+                return [r, g, b, a];
+            }
+            return { r, g, b, a };
+        },
+        // Adjust brightness of a hex color
+        adjust_brightness(color, adjust = 0) {
+            const rgba = this.to_rgb(color);
+            if (Array.isArray(rgba)) {
+                rgba[0] += adjust;
+                rgba[1] += adjust;
+                rgba[2] += adjust;
+                return Colors.rgb.to_hex(rgba[0], rgba[1], rgba[2], rgba[3]);
+            }
+            else {
+                rgba.r += adjust;
+                rgba.g += adjust;
+                rgba.b += adjust;
+                return Colors.rgb.to_hex(rgba.r, rgba.g, rgba.b, rgba.a);
+            }
+        },
+        // Placeholder for aliasing
+        to_rgba: null,
+    },
+    // RGB module
+    rgb: {
+        // RGB(a) to hex
+        to_hex(r, g, b, a = 1) {
+            const hexR = Math.round(r).toString(16).padStart(2, '0');
+            const hexG = Math.round(g).toString(16).padStart(2, '0');
+            const hexB = Math.round(b).toString(16).padStart(2, '0');
+            const hexA = a === 1 ? "" : Math.round(a * 255).toString(16).padStart(2, '0');
+            return `#${hexR}${hexG}${hexB}${hexA}`;
+        },
+        // Convert a color string (e.g., "rgb(255, 0, 0)") to an RGBA object
+        to_obj(color) {
+            if (!color.startsWith("rgba(") && !color.startsWith("rgb(")) {
+                throw new Error("Invalid color format");
+            }
+            const split = color.trim().split("(")[1].slice(0, -1).split(",");
+            const obj = { r: 0, g: 0, b: 0, a: 1 };
+            obj.r = parseInt(split[0].trim());
+            obj.g = parseInt(split[1].trim());
+            obj.b = parseInt(split[2].trim());
+            if (split[3]) {
+                obj.a = parseFloat(split[3].trim());
+            }
+            return obj;
+        },
+        // Convert RGBA values to a color string
+        to_str(r, g, b, a = 1) {
+            if (a !== 1) {
+                return `rgba(${isNaN(r) ? 0 : r}, ${isNaN(g) ? 0 : g}, ${isNaN(b) ? 0 : b}, ${isNaN(a) ? 1 : a})`;
+            }
+            else {
+                return `rgb(${isNaN(r) ? 0 : r}, ${isNaN(g) ? 0 : g}, ${isNaN(b) ? 0 : b})`;
+            }
+        },
+        // Adjust brightness of an RGB color
+        adjust_brightness(color, adjust = 0) {
+            const rgba = this.to_obj(color);
+            rgba.r += adjust;
+            rgba.g += adjust;
+            rgba.b += adjust;
+            return this.to_str(rgba.r, rgba.g, rgba.b, rgba.a);
+        },
+    },
+    // Placeholder for aliasing
+    rgba: null,
+    // Utility function to adjust brightness
+    adjust_brightness(color, adjust = 0) {
+        if (color.startsWith("rgb")) {
+            return this.rgb.adjust_brightness(color, adjust);
+        }
+        else if (color.startsWith("#")) {
+            return this.hex.adjust_brightness(color, adjust);
+        }
+        else {
+            throw new Error("Invalid color format");
+        }
+    },
+    // Set the opacity of a color
+    set_opacity(color, opacity = 1.0) {
+        if (typeof opacity !== "number" || opacity < 0 || opacity > 1) {
+            throw new Error("Invalid opacity [0...1]: " + opacity + ".");
+        }
+        let rgba;
+        let type;
+        if (color.startsWith("rgb")) {
+            type = "rgb";
+            rgba = this.rgb.to_obj(color);
+        }
+        else if (color.startsWith("#")) {
+            type = "hex";
+            const result = this.hex.to_rgb(color);
+            rgba = Array.isArray(result) ? { r: result[0], g: result[1], b: result[2], a: result[3] } : result;
+        }
+        else {
+            throw new Error("Invalid color format");
+        }
+        rgba.a = opacity;
+        if (type === "hex") {
+            return this.rgb.to_hex(rgba.r, rgba.g, rgba.b, rgba.a);
+        }
+        else {
+            return this.rgb.to_str(rgba.r, rgba.g, rgba.b, rgba.a);
+        }
+    },
+    // Darken the color by interpolating toward black (#000000)
+    darken(color, percent = 0.5) {
+        if (typeof percent !== "number" || percent < 0 || percent > 1) {
+            throw new Error("Invalid percentage [0...1]: " + percent + ".");
+        }
+        // Convert input to RGB object
+        const rgb = typeof color === 'string' ? this.hex.to_rgb(color) : {
+            r: color[0],
+            g: color[1],
+            b: color[2],
+            a: color.length > 3 ? color[3] : 1
+        };
+        // Interpolate toward black (0,0,0)
+        const darkened = {
+            r: Math.round(rgb.r * (1 - percent)),
+            g: Math.round(rgb.g * (1 - percent)),
+            b: Math.round(rgb.b * (1 - percent)),
+            a: rgb.a
+        };
+        // Return in same format as input
+        if (typeof color === 'string') {
+            return this.rgb.to_str(darkened.r, darkened.g, darkened.b, darkened.a);
+        }
+        else {
+            return color.length > 3
+                ? [darkened.r, darkened.g, darkened.b, darkened.a]
+                : [darkened.r, darkened.g, darkened.b];
+        }
+    },
+    // Lighten the color by interpolating toward white (#FFFFFF)
+    lighten(color, percent = 0.5) {
+        if (typeof percent !== "number" || percent < 0 || percent > 1) {
+            throw new Error("Invalid percentage [0...1]: " + percent + ".");
+        }
+        // Convert input to RGB object
+        const rgb = typeof color === 'string' ? this.hex.to_rgb(color) : {
+            r: color[0],
+            g: color[1],
+            b: color[2],
+            a: color.length > 3 ? color[3] : 1
+        };
+        // Interpolate toward white (255,255,255)
+        const lightened = {
+            r: Math.round(rgb.r + (255 - rgb.r) * percent),
+            g: Math.round(rgb.g + (255 - rgb.g) * percent),
+            b: Math.round(rgb.b + (255 - rgb.b) * percent),
+            a: rgb.a
+        };
+        // Return in same format as input
+        if (typeof color === 'string') {
+            return this.rgb.to_str(lightened.r, lightened.g, lightened.b, lightened.a);
+        }
+        else {
+            return color.length > 3
+                ? [lightened.r, lightened.g, lightened.b, lightened.a]
+                : [lightened.r, lightened.g, lightened.b];
+        }
+    },
+    // Interpolate.
+    interpolate(start, end, percent = 0.5, alpha = 1.0) {
+        if (typeof percent !== "number" || percent < 0 || percent > 1) {
+            throw new Error("Invalid percentage [0...1]: " + percent + ".");
+        }
+        if (typeof alpha !== "number" || alpha < 0 || alpha > 1) {
+            throw new Error("Invalid alpha [0...1]: " + alpha + ".");
+        }
+        return new ColorRangeClass(start, end).interpolate(percent, alpha);
+    }
+};
+// Aliases
+Colors.hex.to_rgba = Colors.hex.to_rgb;
+Colors.rgba = Colors.rgb;
+// Export
+export { Colors };
+import { Elements } from "../elements/module.js";
+/*	@docs:
+    @nav: Frontend
+    @chapter: Styling
+    @title: Color range
+    @description: Used to create a range between two different colors. Can be initialized using alias function `ColorRange`.
+    @param:
+        @name: start
+        @descr: The start color (lightest). May either be a HEX string or an rgb(a) array.
+        @type: string, array
+    @param:
+        @name: end
+        @descr: The end color (darkest). May either be a HEX string or an rgb(a) array.
+        @type: string, array
+ */
+export class ColorRangeClass {
+    constructor(start, end) {
+        if (Array.isArray(start)) {
+            this.start = this.array_to_rgba(start);
+        }
+        else if (typeof start === "string") {
+            this.start = Colors.hex.to_rgb(start);
+        }
+        else {
+            throw new Error(`Invalid type "${typeof start}" for parameter "start", the valid types are "string" or "array".`);
+        }
+        if (Array.isArray(end)) {
+            this.end = this.array_to_rgba(end);
+        }
+        else if (typeof end === "string") {
+            this.end = Colors.hex.to_rgb(end);
+        }
+        else {
+            throw new Error(`Invalid type "${typeof end}" for parameter "end", the valid types are "string" or "array".`);
+        }
+    }
+    // Array to rgba.
+    array_to_rgba(array) {
+        return {
+            r: isNaN(array[0]) ? 0 : array[0],
+            g: isNaN(array[1]) ? 0 : array[1],
+            b: isNaN(array[2]) ? 0 : array[2],
+            a: array.length < 4 ? 1.0 : isNaN(array[3]) ? 1.0 : array[3],
+        };
+    }
+    /*	@docs:
+        @title: Interpolate
+        @description: Interpolate between the start and end colors. When `percent` is 0 it will return the `start` color and when percent is `1` it will return the end color without computations.
+        @param:
+            @name: percent
+            @descr: The percentage to interpolate from start to end, the valid range is `0.0` till `1.0`.
+            @type: number
+        @param:
+            @name: alpha
+            @descr: The alpha channel, the valid range is `0.0` till `1.0`.
+            @type: number
+            @default: 1
+     */
+    interpolate(percent = 0.5, alpha = 1.0) {
+        // Validate inputs
+        percent = Math.max(0, Math.min(1, percent)); // Clamp percent between 0 and 1
+        alpha = Math.max(0, Math.min(1, alpha)); // Clamp alpha between 0 and 1
+        // Handle edge cases
+        if (percent <= 0) {
+            return Colors.rgb.to_str(this.start.r, this.start.g, this.start.b, this.start.a);
+        }
+        else if (percent >= 1) {
+            console.log("END:", this.end);
+            return Colors.rgb.to_str(this.end.r, this.end.g, this.end.b, this.end.a);
+        }
+        // Ensure all RGB values are valid numbers (default to 0 if invalid)
+        const startR = isNaN(this.start.r) ? 0 : this.start.r;
+        const startG = isNaN(this.start.g) ? 0 : this.start.g;
+        const startB = isNaN(this.start.b) ? 0 : this.start.b;
+        const endR = isNaN(this.end.r) ? 0 : this.end.r;
+        const endG = isNaN(this.end.g) ? 0 : this.end.g;
+        const endB = isNaN(this.end.b) ? 0 : this.end.b;
+        // Perform interpolation with validated values
+        return Colors.rgba.to_str(Math.round(startR + (endR - startR) * percent), Math.round(startG + (endG - startG) * percent), Math.round(startB + (endB - startB) * percent), alpha);
+    }
+}
+export const ColorRange = Elements.wrapper(ColorRangeClass);
+export const NullColorRange = Elements.create_null(ColorRangeClass);

package/frontend/dist/modules/compression.d.ts

@@ -0,0 +1,6 @@
+export declare const Compression: {
+    compress(data: string | object, options?: {
+        level?: number;
+    }): Uint8Array;
+    decompress(data: Uint8Array, type?: string): string | any[] | object;
+};