@vandenberghinc/volt 1.1.4 → 1.1.6

package/frontend/dist/elements/module.d.ts

@@ -1,16 +1,30 @@
 export * from "./base.js";
 import { VElement, extend as extend_velement, wrapper as _wrapper, create_null as _create_null } from "./base.js";
+import { register_element as _register_element } from "./register_element.js";
 export declare namespace Elements {
-    function get(id: string): VElement;
-    function get_by_id(id: string): VElement;
-    function click(id: string): void;
-    function register_type(type: any, tag?: string): void;
-    function register<T extends {
-        new (...args: any[]): {};
-    }>(constructor: T): void;
-    const wrapper: typeof _wrapper;
-    const create_null: typeof _create_null;
-    function submit(...elements: (string | VElement | HTMLElement)[]): Record<string, any>;
-    function forward_func_to_child(func_name: string, child: any): (val?: any) => any;
-    const extend: typeof extend_velement;
+    export const register_element: typeof _register_element;
+    export function get(id: string): VElement;
+    export function get_by_id(id: string): VElement;
+    export function click(id: string): void;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    interface CreateOpts {
+        name: string;
+        tag?: string;
+        default_style?: Record<string, any>;
+        default_attributes?: Record<string, any>;
+        default_events?: Record<string, any>;
+    }
+    /**
+     * Class decorator factory.
+     * @example
+     *   @create({ name: "Foo", tag?: "section", base: HTMLElement })
+     *   class Foo extends HTMLElement { … }
+     */
+    export function create(opts: CreateOpts): <T extends Constructor>(constructor: T) => T;
+    export const wrapper: typeof _wrapper;
+    export const create_null: typeof _create_null;
+    export function submit(...elements: (string | VElement | HTMLElement)[]): Record<string, any>;
+    export function forward_func_to_child(func_name: string, child: any): (val?: any) => any;
+    export const extend: typeof extend_velement;
+    export {};
 }

package/frontend/dist/elements/module.js

@@ -5,8 +5,11 @@
 // Import elements create func.
 export * from "./base.js";
 import { extend as extend_velement, wrapper as _wrapper, create_null as _create_null, } from "./base.js";
+import { register_element as _register_element } from "./register_element.js";
+// Elements module.
 export var Elements;
 (function (Elements) {
+    Elements.register_element = _register_element;
     // Get by id.
     // @note: always use VElement as return type since this is most likely the case and avoids type casting for users.
     /*  @docs:
@@ -61,39 +64,73 @@ export var Elements;
         }
     }
     Elements.click = click;
-    // Register a custom type.
-    /*  @docs:
-        @nav: Frontend
-        @chapter: Elements
-        @title: Register Custom Type
-        @desc: Registers a custom element type.
-        @param:
-            @name: type
-            @description The custom element type (class).
-        @param:
-            @name: tag
-            @description Optional tag name to extend.
-    */
-    function register_type(type, tag) {
-        type._is_registered = true;
-        // customElements.define(type.name, type, { extends: tag || (type as any).element_tag });
-        customElements.define("v-" + type.name.toLowerCase(), type, { extends: tag || type.element_tag });
-    }
-    Elements.register_type = register_type;
-    // Register decorator.
-    /*  @docs:
-        @nav: Frontend
-        @chapter: Elements
-        @title: Register Decorator
-        @desc: Registers a class as a custom element.
-        @param:
-            @name: constructor
-            @description The class constructor to register.
-    */
-    function register(constructor) {
-        Elements.register_type(constructor);
+    /**
+     * Class decorator factory.
+     * @example
+     *   @create({ name: "Foo", tag?: "section", base: HTMLElement })
+     *   class Foo extends HTMLElement { … }
+     */
+    function create(opts) {
+        // Validate required options at factory time
+        if (typeof opts.name !== "string" || opts.name.trim() === "") {
+            throw new Error(`@Elements.create requires a non-empty string “name”`);
+        }
+        // Factory function
+        return function (constructor) {
+            const any_ctor = constructor;
+            // Define readonly static attributes.
+            any_ctor.element_name = opts.name;
+            // Object.defineProperty(any_ctor, "element_name", { value: opts.name, writable: false, enumerable: true, configurable: false });
+            if (opts.tag != null) {
+                any_ctor.element_tag = opts.tag;
+                // Object.defineProperty(any_ctor, "element_tag", { value: opts.tag, writable: false, enumerable: true, configurable: false });
+            }
+            if (opts.default_style != null) {
+                any_ctor.default_style = opts.default_style;
+                // Object.defineProperty(any_ctor, "default_style", { value: opts.default_style, writable: false, enumerable: true, configurable: false });
+            }
+            if (opts.default_attributes != null) {
+                any_ctor.default_attributes = opts.default_attributes;
+                // Object.defineProperty(any_ctor, "default_attributes", { value: opts.default_attributes, writable: false, enumerable: true, configurable: false });
+            }
+            if (opts.default_events != null) {
+                any_ctor.default_events = opts.default_events;
+                // Object.defineProperty(any_ctor, "default_events", { value: opts.default_events, writable: false, enumerable: true, configurable: false });
+            }
+            // Register custom element exactly once
+            _register_element(constructor);
+            return constructor;
+        };
     }
-    Elements.register = register;
+    Elements.create = create;
+    // export function create<T extends { new(...args: any[]): {} }>(constructor: T): void {
+    //     const any_con = constructor as any;
+    //     // Register new html element.
+    //     if (!any_con._volt_is_registered) {
+    //         console.log({ type: constructor })
+    //         if (!any_con.element_name) {
+    //             throw new Error(`Static element attribute '${any_con.name}.element_name' should always be defined, create static attribute \"element_name: string\" and assign the name of the class to this attribute.`)
+    //         }
+    //         const name = any_con.element_name || any_con.name;
+    //         let new_xml_name = "", count = 0;
+    //         do {
+    //             new_xml_name = "v-" + name.toLowerCase() + (count > 0 ? "-" + count : "");
+    //         } while (registered_type_names.has(new_xml_name) && ++count);
+    //         registered_type_names.add(new_xml_name);
+    //         const ext = tag || any_con.element_tag;
+    //         // @debug
+    //         console.log("Registering custom element: ", {
+    //             name,
+    //             type: constructor,
+    //             new_xml_name,
+    //             extends: ext,
+    //             element_name: any_con.element_name,
+    //         });
+    //         any_con._volt_is_registered = true;
+    //         // customElements.define(type.name, type, { extends: tag || (type as any).element_tag });
+    //         customElements.define(new_xml_name, any_con, { extends: ext });
+    //     }
+    // }
     // Create a constructor wrapper.
     Elements.wrapper = _wrapper;
     // Create a shared null element mainly for typescript types.

package/frontend/dist/elements/register_element.d.ts

@@ -0,0 +1,3 @@
+/** Separate file for register_element() method to prevent recursive imports from base.ts and module.ts */
+export declare const registered_names: Set<string>;
+export declare function register_element(constructor: any): void;

package/frontend/dist/elements/register_element.js

@@ -0,0 +1,22 @@
+/** Separate file for register_element() method to prevent recursive imports from base.ts and module.ts */
+export const registered_names = new Set();
+export function register_element(constructor) {
+    // @warning dont use any caching on the constructor, it will break the element registration since the constructor can be used as base class.
+    const any_ctor = constructor;
+    if (!any_ctor.element_name) {
+        console.error("Error constructor:", constructor);
+        throw new Error("Static element attribute 'element_name' should always be defined, create static attribute \"element_name: string\" and assign the name of the class to this attribute.");
+    }
+    const base_name = any_ctor.element_name;
+    let new_tag = "";
+    let count = 0;
+    do {
+        new_tag = `v-${base_name.toLowerCase()}${count ? `-${count}` : ""}`;
+        count++;
+    } while (registered_names.has(new_tag));
+    registered_names.add(new_tag);
+    const extend_options = any_ctor.element_tag
+        ? { extends: any_ctor.element_tag }
+        : undefined;
+    customElements.define(new_tag, any_ctor, extend_options);
+}

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

@@ -43,3 +43,4 @@ export declare namespace Auth {
     }): Promise<Auth.ForgotPasswordResponse>;
     export {};
 }
+export { Auth as auth };

package/frontend/dist/modules/auth.js

@@ -32,7 +32,7 @@ export var Auth;
             @description The user's 2fa code. Only required when 2fa is enabled in the server.
      */
     function sign_in({ email = "", username = "", password = "", code = "", }) {
-        return Utils.request({
+        return Utils.request_v1({
             method: "POST",
             url: "/volt/auth/signin",
             data: {
@@ -52,7 +52,7 @@ export var Auth;
         @desc: Make a sign up request.
      */
     function sign_up({ username = "", email = "", first_name = "", last_name = "", password = "", verify_password = "", phone_number = "", code = "", }) {
-        return Utils.request({
+        return Utils.request_v1({
             method: "POST",
             url: "/volt/auth/signup",
             data: {
@@ -76,7 +76,7 @@ export var Auth;
         @desc: Make a sign out request.
      */
     function sign_out() {
-        return Utils.request({
+        return Utils.request_v1({
             method: "POST",
             url: "/volt/auth/signout",
         });
@@ -93,7 +93,7 @@ export var Auth;
             @description The user's email.
      */
     function send_2fa(email) {
-        return Utils.request({
+        return Utils.request_v1({
             method: "GET",
             url: "/volt/auth/2fa",
             data: {
@@ -122,7 +122,7 @@ export var Auth;
             @description The user's new password.
      */
     function forgot_password({ email = "", code = "", password = "", verify_password = "", }) {
-        return Utils.request({
+        return Utils.request_v1({
             method: "POST",
             url: "/volt/auth/forgot_password",
             data: {
@@ -136,3 +136,4 @@ export var Auth;
     Auth.forgot_password = forgot_password;
 })(Auth || (Auth = {}));
 ;
+export { Auth as auth }; // also export as lowercase for compatibility.

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

@@ -0,0 +1,159 @@
+/**
+ * A utility class for color manipulation, conversion, and adjustment.
+ * Accepts colors in hex (e.g. "#ff0000"), RGB/RGBA strings (e.g. "rgb(255, 0, 0)" or "rgba(255,0,0,1)"),
+ * or as an array of numbers ([r, g, b] or [r, g, b, a]).
+ *
+ * All transformation methods (adjust_brightness, darken, lighten, interpolate, etc.) return a new Color instance,
+ * so they can be chained in a single line.
+ */
+export declare class Color {
+    static readonly black: string;
+    static readonly red: string;
+    static readonly red_bold: string;
+    static readonly green: string;
+    static readonly yellow: string;
+    static readonly blue: string;
+    static readonly magenta: string;
+    static readonly cyan: string;
+    static readonly light_gray: string;
+    static readonly gray: string;
+    static readonly bold: string;
+    static readonly italic: string;
+    static readonly end: string;
+    static readonly purple: string;
+    static readonly bg: Record<'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white', string>;
+    static readonly bright_bg: Record<'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white', string>;
+    private readonly _rgba;
+    /**
+     * Creates a new Color instance.
+     * @param input - A hex string, an "rgb(...)" / "rgba(...)" string, or an array of numbers ([r, g, b] or [r, g, b, a]).
+     */
+    constructor(input: string | number[]);
+    /**
+     * Converts input into an RGBA object.
+     * @private
+     */
+    private static _from_input;
+    /**
+     * Converts a numeric array to an RGBA object.
+     * @param array - An array of numbers representing [r, g, b] or [r, g, b, a].
+     */
+    static array_to_rgba(array: number[]): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /**
+     * Converts a hex color string to an RGBA object or an array.
+     * @param hex - The hex color string (with or without "#").
+     * @param as_array - If true, returns an array [r, g, b, a]; otherwise an object.
+     */
+    static hex_to_rgb(hex: string, as_array: true): number[];
+    static hex_to_rgb(hex: string, as_array?: false): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /**
+     * Converts an "rgb(...)" or "rgba(...)" string to an RGBA object.
+     * @param color - The RGB(A) color string.
+     * @throws Error if the color format is invalid.
+     */
+    static rgb_to_obj(color: string): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /**
+     * Converts RGBA values to a hex color string.
+     * @param r - Red channel value.
+     * @param g - Green channel value.
+     * @param b - Blue channel value.
+     * @param a - Alpha channel value (defaults to 1).
+     */
+    static rgb_to_hex(r: number, g: number, b: number, a?: number): string;
+    /**
+     * Converts RGBA values to an "rgb(...)" or "rgba(...)" string.
+     * @param r - Red channel.
+     * @param g - Green channel.
+     * @param b - Blue channel.
+     * @param a - Alpha channel (defaults to 1).
+     */
+    static rgb_to_str(r: number, g: number, b: number, a?: number): string;
+    /**
+     * Returns the hex string representation of this Color.
+     */
+    to_hex(): string;
+    hex(): string;
+    /**
+     * Returns the RGB(A) string representation of this Color.
+     */
+    str(): string;
+    to_str(): string;
+    to_rgb(): string;
+    rgb(): string;
+    /**
+     * Returns the brightness of the color.
+     * Uses the formula: (0.299*R + 0.587*G + 0.114*B) / 255.
+     * @returns A number between 0 (bright) and 1 (dark).
+     */
+    private get_brightness;
+    /**
+     * Adjusts the brightness of the color by adding a constant to each RGB channel.
+     * @param adjust - The value to add (can be negative).
+     * @returns A new Color instance with modified brightness.
+     */
+    adjust_brightness(adjust: number): Color;
+    /** Get opacity. */
+    get_opacity(): number;
+    /**
+     * Sets the opacity (alpha channel) of the color.
+     * @param opacity - A number between 0 and 1.
+     * @returns A new Color instance with the given opacity.
+     * @throws Error if the opacity is not within [0,1].
+     */
+    opacity(opacity?: number): Color;
+    /**
+     * Darkens the color by interpolating toward black.
+     * @param percent - The percentage to darken (between 0 and 1).
+     * @returns A new Color instance darkened by the specified percentage.
+     * @throws Error if the percentage is not within [0,1].
+     */
+    darken(percent?: number): Color;
+    /**
+     * Lightens the color by interpolating toward white.
+     * @param percent - The percentage to lighten (between 0 and 1).
+     * @returns A new Color instance lightened by the specified percentage.
+     * @throws Error if the percentage is not within [0,1].
+     */
+    lighten(percent?: number): Color;
+    /**
+     * Automatically darken when the color is bright or lighten when the color is dark.
+     *
+     * @param evaluation When the evaluation returns true the color will be darkened.
+     */
+    auto_darken_lighten(percent?: number, evaluation?: (brightness: number) => boolean): Color;
+    /**
+     * Interpolates between this color and an end color.
+     * When percent is 0 the original color is returned, and when 1 the end color is returned.
+     * @param end - The target color (hex string, rgb(a) string, number array, or Color).
+     * @param percent - The interpolation factor (0 to 1).
+     * @param alpha - The resulting alpha value (0 to 1).
+     * @returns A new Color instance representing the interpolated color.
+     * @throws Error if percent or alpha are out of range.
+     */
+    interpolate(end: string | number[] | Color, percent?: number, alpha?: number): Color;
+    /**
+     * Returns the opposite (contrasting) color.
+     * Returns black ("#000000") if the color is bright, or white ("#ffffff") if it is dark.
+     * @returns A new Color instance that is either black or white.
+     */
+    opposite(): Color;
+    static opposite_s(color: ConstructorParameters<typeof Color>[0]): Color;
+    opposite_hex(): "#000000" | "#ffffff";
+    static opposite_hex_s(color: ConstructorParameters<typeof Color>[0]): "#000000" | "#ffffff";
+}
+export { Color as color };