@vandenberghinc/volt 1.1.2

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

@@ -0,0 +1,16 @@
+export * from "./base.js";
+import { VElement, extend as extend_velement, wrapper as _wrapper, create_null as _create_null } from "./base.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;
+}

package/frontend/dist/elements/module.js

@@ -0,0 +1,178 @@
+/*
+ * Author: Daan van den Bergh
+ * Copyright: © 2022 - 2024 Daan van den Bergh.
+ */
+// Import elements create func.
+export * from "./base.js";
+import { extend as extend_velement, wrapper as _wrapper, create_null as _create_null, } from "./base.js";
+export var Elements;
+(function (Elements) {
+    // Get by id.
+    // @note: always use VElement as return type since this is most likely the case and avoids type casting for users.
+    /*  @docs:
+        @nav: Frontend
+        @chapter: Elements
+        @title: Get Element by ID
+        @desc: Get an element by its ID.
+        @param:
+            @name: id
+            @description The ID of the element.
+    */
+    function get(id) {
+        const e = document.getElementById(id);
+        if (e == null) {
+            throw new Error(`Unable to find element with id "${id}".`);
+        }
+        return e;
+    }
+    Elements.get = get;
+    // Get by id (alias).
+    // @note: always use VElement as return type since this is most likely the case and avoids type casting for users.
+    /*  @docs:
+        @nav: Frontend
+        @chapter: Elements
+        @title: Get Element by ID (Alias)
+        @desc: Alias for `get` to get an element by its ID.
+        @param:
+            @name: id
+            @description The ID of the element.
+    */
+    function get_by_id(id) {
+        return Elements.get(id);
+    }
+    Elements.get_by_id = get_by_id;
+    // Click an element by id.
+    /*  @docs:
+        @nav: Frontend
+        @chapter: Elements
+        @title: Click Element by ID
+        @desc: Programmatically clicks an element by its ID.
+        @param:
+            @name: id
+            @description The ID of the element.
+    */
+    function click(id) {
+        const element = document.getElementById(id);
+        if (element) {
+            element.click();
+        }
+        else {
+            throw new Error(`Unable to find element with id "${id}".`);
+        }
+    }
+    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);
+    }
+    Elements.register = register;
+    // Create a constructor wrapper.
+    Elements.wrapper = _wrapper;
+    // Create a shared null element mainly for typescript types.
+    Elements.create_null = _create_null;
+    // Submit multiple elements by id or element.
+    // When one is not filled in then an error is thrown.
+    // When an input is not required, no errors will be thrown.
+    // An object will be returned with each input's id as the key and the input's value as value.
+    // Only supported extended input elements like `ExtendedInput`.
+    /*  @docs:
+        @nav: Frontend
+        @chapter: Elements
+        @title: Submit Elements
+        @desc: Submits multiple elements by ID or reference.
+        @deprecated: true
+        @param:
+            @name: elements
+            @description A list of element IDs or element references to submit.
+    */
+    function submit(...elements) {
+        const params = {};
+        let error;
+        for (let i = 0; i < elements.length; i++) {
+            try {
+                let element = elements[i];
+                if (typeof element === "string") {
+                    element = Elements.get(element);
+                }
+                const id = element.id();
+                if (id == null || id === "") {
+                    continue;
+                }
+                if (element.required() !== true) {
+                    params[id] = element.value();
+                }
+                else {
+                    params[id] = element.submit();
+                }
+            }
+            catch (e) {
+                error = e;
+            }
+        }
+        if (error) {
+            throw error;
+        }
+        return params;
+    }
+    Elements.submit = submit;
+    // Forward a function to a child so a user can easily create functions on the parent like border_radius() which actually set the border radius of a child.
+    // The new function still returns `this`.
+    /*  @docs:
+        @nav: Frontend
+        @chapter: Elements
+        @title: Forward Function to Child
+        @desc: Forwards a function to a child element.
+        @param:
+            @name: func_name
+            @description The name of the function to forward.
+        @param:
+            @name: child
+            @description The child element or a function that returns the child element.
+    */
+    function forward_func_to_child(func_name, child) {
+        return function (val) {
+            if (typeof child === "function") {
+                child = child(this);
+            }
+            if (val == null) {
+                return child[func_name]();
+            }
+            child[func_name](val);
+            return this;
+        };
+    }
+    Elements.forward_func_to_child = forward_func_to_child;
+    // Update the extend_velement function to use proper types
+    Elements.extend = extend_velement;
+    // Create.
+    // export const create = create_velement;
+})(Elements || (Elements = {}));
+;

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

@@ -0,0 +1,37 @@
+declare global {
+    interface Array<T> {
+        append(...items: T[]): number;
+        first(): T | undefined;
+        last(): T | undefined;
+        iterate(handler: (item: T, index: number, array: T[]) => any): any;
+        iterate(start: number, handler: (item: T, index: number, array: T[]) => any): any;
+        iterate(start: number, end: number, handler: (item: T, index: number, array: T[]) => any): any;
+        iterate_async(handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_async(start: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_async(start: number, end: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_async_await(handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        iterate_async_await(start: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        iterate_async_await(start: number, end: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        iterate_append(handler: (item: T, index: number, array: T[]) => any): any[];
+        iterate_append(start: number, handler: (item: T, index: number, array: T[]) => any): any[];
+        iterate_append(start: number, end: number, handler: (item: T, index: number, array: T[]) => any): any[];
+        iterate_reversed(handler: (item: T, index: number, array: T[]) => any): any;
+        iterate_reversed(start: number, handler: (item: T, index: number, array: T[]) => any): any;
+        iterate_reversed(start: number, end: number, handler: (item: T, index: number, array: T[]) => any): any;
+        iterate_reversed_async(handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_reversed_async(start: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_reversed_async(start: number, end: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any[]>;
+        iterate_reversed_async_await(handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        iterate_reversed_async_await(start: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        iterate_reversed_async_await(start: number, end: number, handler: (item: T, index: number, array: T[]) => Promise<any>): Promise<any>;
+        drop(item: T): T[];
+        drop_index(index: number): T[];
+        drop_duplicates(): T[];
+        limit_from_end(limit: number): T[];
+        remove(item: T): T[];
+        eq(otherArray: any[]): boolean;
+        eq(x: any, y: any): boolean;
+        divide(x: number): T[][];
+    }
+}
+export {};

package/frontend/dist/modules/array.js

@@ -0,0 +1,284 @@
+/*
+ * Author: Daan van den Bergh
+ * Copyright: © 2022 - 2024 Daan van den Bergh.
+ */
+// Append alias for push.
+Array.prototype.append = Array.prototype.push;
+// Get the first and last item.
+Array.prototype.first = function () {
+    return this[0];
+};
+// Get the first and last item.
+Array.prototype.last = function () {
+    return this[this.length - 1];
+};
+// Iteration function for arrays.
+Array.prototype.iterate = function (start, end, handler) {
+    if (typeof start === "function") {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    for (let i = start; i < end; i++) {
+        const res = handler(this[i]);
+        if (res != null && !(res instanceof Promise)) {
+            return res;
+        }
+    }
+    return null;
+};
+Array.prototype.iterate_async = function (start, end, handler) {
+    if (typeof start === "function") {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    let promises = [];
+    for (let i = start; i < end; i++) {
+        const res = handler(this[i]);
+        if (res != null && res instanceof Promise) {
+            promises.push(res);
+        }
+    }
+    return promises;
+};
+Array.prototype.iterate_async_await = async function (start, end, handler) {
+    if (typeof start === "function") {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    for (let i = start; i < end; i++) {
+        const res = handler(this[i]);
+        if (res != null && res instanceof Promise) {
+            const pres = await res;
+            if (pres != null) {
+                return pres;
+            }
+        }
+    }
+    return null;
+};
+// Iteration function for arrays to build an array by another array, it appends all the returned callback values into an array and returns that array. Quite useful for volt.
+Array.prototype.iterate_append = function (start, end, handler) {
+    if (typeof start === "function") {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    const items = [];
+    for (let i = start; i < end; i++) {
+        items.append(handler(this[i]));
+    }
+    return items;
+};
+// Iterate an array reversed.
+Array.prototype.iterate_reversed = function (start, end, handler) {
+    if (handler == null && start != null) {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    for (let i = end - 1; i >= start; i--) {
+        const res = handler(this[i]);
+        if (res != null && !(res instanceof Promise)) {
+            return res;
+        }
+    }
+    return null;
+};
+Array.prototype.iterate_reversed_async = function (start, end, handler) {
+    if (handler == null && start != null) {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    let promises = [];
+    for (let i = end - 1; i >= start; i--) {
+        const res = handler(this[i]);
+        if (res != null && res instanceof Promise) {
+            promises.push(res);
+        }
+    }
+    return promises;
+};
+Array.prototype.iterate_reversed_async_await = async function (start, end, handler) {
+    if (handler == null && start != null) {
+        handler = start;
+        start = null;
+    }
+    if (start == null) {
+        start = 0;
+    }
+    if (end == null) {
+        end = this.length;
+    }
+    for (let i = end - 1; i >= start; i--) {
+        const res = handler(this[i]);
+        if (res != null && res instanceof Promise) {
+            const pres = await res;
+            if (pres != null) {
+                return pres;
+            }
+        }
+    }
+    return null;
+};
+// Drop an item by the item itself.
+Array.prototype.drop = function (item) {
+    // @ts-expect-error
+    const dropped = new this.constructor(); // for when a class extends Array.
+    for (let i = 0; i < this.length; i++) {
+        if (this[i] !== item) {
+            dropped.push(this[i]);
+        }
+    }
+    return dropped;
+};
+// Drop an item by index.
+Array.prototype.drop_index = function (index) {
+    // @ts-expect-error
+    const dropped = new this.constructor(); // for when a class extends Array.
+    for (let i = 0; i < this.length; i++) {
+        if (i != index) {
+            dropped.push(this[i]);
+        }
+    }
+    return dropped;
+};
+// Drop duplicate items from an array.
+Array.prototype.drop_duplicates = function () {
+    return this.reduce((accumulator, val) => {
+        if (!accumulator.includes(val)) {
+            accumulator.push(val);
+        }
+        return accumulator;
+    }, []);
+};
+// Limit from end, always creates a new array.
+Array.prototype.limit_from_end = function (limit) {
+    let limited = [];
+    if (this.length > limit) {
+        for (let i = this.length - limit; i < this.length; i++) {
+            limited.push(this[i]);
+        }
+    }
+    else {
+        for (let i = 0; i < this.length; i++) {
+            limited.push(this[i]);
+        }
+    }
+    return limited;
+};
+// Remove all items that equal the item from the array.
+Array.prototype.remove = function (item) {
+    let removed = [];
+    this.iterate((i) => {
+        if (i != item) {
+            removed.push(i);
+        }
+    });
+    return removed;
+};
+// Check if an array equals another array.
+// When the second parameter is not passed `this` will be used as `x` and `x` will be used as `y`.
+Array.prototype.eq = function (x, y) {
+    const eq = (x, y) => {
+        // Arrays.
+        if (Array.isArray(x)) {
+            if (Array.isArray(y) === false ||
+                x.length !== y.length) {
+                return false;
+            }
+            for (let i = 0; i < x.length; i++) {
+                if (typeof x[i] === "object" || typeof y[i] === "object") {
+                    const result = eq(x[i], y[i]);
+                    if (result === false) {
+                        return false;
+                    }
+                }
+                else if (x[i] !== y[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Objects.
+        else if (typeof x === "object") {
+            if (typeof y !== "object" ||
+                Array.isArray(y)) {
+                return false;
+            }
+            const x_keys = Object.keys(x);
+            const y_keys = Object.keys(y);
+            if (eq(x_keys, y_keys) === false) {
+                return false;
+            }
+            for (let i = 0; i < x_keys.length; i++) {
+                if (typeof x[x_keys[i]] === "object" || typeof y[y_keys[i]] === "object") {
+                    const result = eq(x[x_keys[i]], y[y_keys[i]]);
+                    if (result === false) {
+                        return false;
+                    }
+                }
+                else if (x[x_keys[i]] !== y[y_keys[i]]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Others.
+        else if (typeof x !== typeof y) {
+            return false;
+        }
+        return x === y;
+    };
+    if (y == null) {
+        y = x;
+        x = this;
+    }
+    return eq(x, y);
+};
+// Divide into nested arrays.
+Array.prototype.divide = function (x) {
+    if (typeof x !== 'number' || x <= 0) {
+        throw new Error('Number of nested arrays must be a positive number');
+    }
+    const result = [];
+    const nested_len = Math.ceil(this.length / x);
+    for (let i = 0; i < this.length; i += nested_len) {
+        result.push(this.slice(i, i + nested_len));
+    }
+    return result;
+};
+export {};

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

@@ -0,0 +1,45 @@
+export declare namespace Auth {
+    interface Response {
+        error?: string;
+        invalid_fields?: Record<string, string>;
+        message?: string;
+    }
+    interface MessageResponse {
+        message?: string;
+    }
+    export interface SignInResponse extends Response {
+    }
+    export interface SignUpResponse extends Response {
+    }
+    export interface SignOutResponse extends MessageResponse {
+    }
+    export interface Send2FAResponse extends MessageResponse {
+    }
+    export interface ForgotPasswordResponse extends Response {
+    }
+    export function sign_in({ email, username, password, code, }: {
+        username: string;
+        email: string;
+        password: string;
+        code?: string;
+    }): Promise<Auth.SignInResponse>;
+    export function sign_up({ username, email, first_name, last_name, password, verify_password, phone_number, code, }: {
+        username: string;
+        email: string;
+        first_name: string;
+        last_name: string;
+        password: string;
+        verify_password: string;
+        phone_number?: string;
+        code?: string;
+    }): Promise<Auth.SignUpResponse>;
+    export function sign_out(): Promise<Auth.SignOutResponse>;
+    export function send_2fa(email: string): Promise<Auth.Send2FAResponse>;
+    export function forgot_password({ email, code, password, verify_password, }: {
+        email: string;
+        password: string;
+        verify_password: string;
+        code: string;
+    }): Promise<Auth.ForgotPasswordResponse>;
+    export {};
+}

package/frontend/dist/modules/auth.js

@@ -0,0 +1,138 @@
+/*
+ * Author: Daan van den Bergh
+ * Copyright: © 2022 - 2024 Daan van den Bergh.
+ */
+// Imports.
+import { Utils } from "./utils.js";
+// Namespace.
+export var Auth;
+(function (Auth) {
+    ;
+    ;
+    ;
+    ;
+    ;
+    // Sign in.
+    /*	@docs:
+        @nav: Frontend
+        @chapter: Authentication
+        @title: Sign In
+        @desc: Make a sign in request.
+        @param:
+            @name: email
+            @description The user's email. Either the username or email is required.
+        @param:
+            @name: username
+            @description The user's username. Either the username or email is required.
+        @param:
+            @name: password
+            @description The user's password.
+        @param:
+            @name: code
+            @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({
+            method: "POST",
+            url: "/volt/auth/signin",
+            data: {
+                email: email,
+                username: username,
+                password: password,
+                code: code,
+            },
+        });
+    }
+    Auth.sign_in = sign_in;
+    // Sign up.
+    /*	@docs:
+        @nav: Frontend
+        @chapter: Authentication
+        @title: Sign Up
+        @desc: Make a sign up request.
+     */
+    function sign_up({ username = "", email = "", first_name = "", last_name = "", password = "", verify_password = "", phone_number = "", code = "", }) {
+        return Utils.request({
+            method: "POST",
+            url: "/volt/auth/signup",
+            data: {
+                username,
+                email,
+                first_name,
+                last_name,
+                password,
+                verify_password,
+                phone_number,
+                code,
+            },
+        });
+    }
+    Auth.sign_up = sign_up;
+    // Sign out.
+    /*	@docs:
+        @nav: Frontend
+        @chapter: Authentication
+        @title: Sign Out
+        @desc: Make a sign out request.
+     */
+    function sign_out() {
+        return Utils.request({
+            method: "POST",
+            url: "/volt/auth/signout",
+        });
+    }
+    Auth.sign_out = sign_out;
+    // Send 2fa.
+    /*	@docs:
+        @nav: Frontend
+        @chapter: Authentication
+        @title: Send 2FA
+        @desc: Make a send 2FA request.
+        @param:
+            @name: email
+            @description The user's email.
+     */
+    function send_2fa(email) {
+        return Utils.request({
+            method: "GET",
+            url: "/volt/auth/2fa",
+            data: {
+                email: email,
+            },
+        });
+    }
+    Auth.send_2fa = send_2fa;
+    // Forgot password.
+    /*	@docs:
+        @nav: Frontend
+        @chapter: Authentication
+        @title: Forgot Password
+        @desc: Make a forgot password request.
+        @param:
+            @name: email
+            @description The user's email.
+        @param:
+            @name: code
+            @description The user's 2fa code.
+        @param:
+            @name: password
+            @description The user's new password.
+        @param:
+            @name: verify_password
+            @description The user's new password.
+     */
+    function forgot_password({ email = "", code = "", password = "", verify_password = "", }) {
+        return Utils.request({
+            method: "POST",
+            url: "/volt/auth/forgot_password",
+            data: {
+                email: email,
+                code: code,
+                password: password,
+                verify_password: verify_password,
+            },
+        });
+    }
+    Auth.forgot_password = forgot_password;
+})(Auth || (Auth = {}));
+;