danholibraryjs 1.11.0 → 2.0.0

package/dist/Utils/ApiUtil/index.d.ts

@@ -1,20 +1,20 @@
-import { ApiUtilOptions, RequestOptions } from "./ApiTypes";
-export declare class ApiUtil<ApiEndpoints extends string> {
-    protected __baseEndpointDev: string;
-    protected __baseEndpoint?: string;
-    protected __log: boolean;
-    constructor({ baseEndpointDev, baseEndpoint, log }: ApiUtilOptions);
-    /**
-     * Make a request to the API
-     * @param path The path to the endpoint
-     * @param options The options for the request
-     * @returns The response from the API
-     */
-    request<TData>(path: ApiEndpoints, options?: RequestOptions): Promise<{
-        success: boolean;
-        status: number;
-        data: TData;
-        text: string;
-    }>;
-    get baseEndpoint(): string;
-}
+import { ApiUtilOptions, RequestOptions } from "./ApiTypes";
+export declare class ApiUtil<ApiEndpoints extends string> {
+    protected __baseEndpointDev: string;
+    protected __baseEndpoint?: string;
+    protected __log: boolean;
+    constructor({ baseEndpointDev, baseEndpoint, log }: ApiUtilOptions);
+    /**
+     * Make a request to the API
+     * @param path The path to the endpoint
+     * @param options The options for the request
+     * @returns The response from the API
+     */
+    request<TData>(path: ApiEndpoints, options?: RequestOptions): Promise<{
+        success: boolean;
+        status: number;
+        data: TData;
+        text: string;
+    }>;
+    get baseEndpoint(): string;
+}

package/dist/Utils/ApiUtil/index.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiUtil = void 0;
-const RequestUtil_1 = require("./RequestUtil");
-class ApiUtil {
-    __baseEndpointDev;
-    __baseEndpoint;
-    __log;
-    constructor({ baseEndpointDev, baseEndpoint, log }) {
-        this.__baseEndpointDev = baseEndpointDev;
-        this.__baseEndpoint = baseEndpoint;
-        this.__log = log ?? false;
-    }
-    /**
-     * Make a request to the API
-     * @param path The path to the endpoint
-     * @param options The options for the request
-     * @returns The response from the API
-     */
-    async request(path, options) {
-        return (0, RequestUtil_1.Request)(path, {
-            ...options,
-            baseEndpoint: this.baseEndpoint
-        }, this.__log);
-    }
-    get baseEndpoint() {
-        const processExists = 'process' in globalThis;
-        // @ts-ignore -- process is not defined in the browser
-        const isDev = processExists && process.env.NODE_ENV === 'development';
-        return isDev ? this.__baseEndpointDev : this.__baseEndpoint ?? this.__baseEndpointDev;
-    }
-}
-exports.ApiUtil = ApiUtil;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiUtil = void 0;
+const RequestUtil_1 = require("./RequestUtil");
+class ApiUtil {
+    __baseEndpointDev;
+    __baseEndpoint;
+    __log;
+    constructor({ baseEndpointDev, baseEndpoint, log }) {
+        this.__baseEndpointDev = baseEndpointDev;
+        this.__baseEndpoint = baseEndpoint;
+        this.__log = log ?? false;
+    }
+    /**
+     * Make a request to the API
+     * @param path The path to the endpoint
+     * @param options The options for the request
+     * @returns The response from the API
+     */
+    async request(path, options) {
+        return (0, RequestUtil_1.Request)(path, {
+            ...options,
+            baseEndpoint: this.baseEndpoint
+        }, this.__log);
+    }
+    get baseEndpoint() {
+        const processExists = 'process' in globalThis;
+        // @ts-ignore -- process is not defined in the browser
+        const isDev = processExists && process.env.NODE_ENV === 'development';
+        return isDev ? this.__baseEndpointDev : this.__baseEndpoint ?? this.__baseEndpointDev;
+    }
+}
+exports.ApiUtil = ApiUtil;

package/dist/Utils/ApiUtils/ApiTypes.d.ts

@@ -0,0 +1,15 @@
+export type TParam = string | undefined;
+export type HttpMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type RequestOptions<TBody = any> = Omit<RequestInit, 'method' | 'body'> & {
+    method?: HttpMethods;
+    body?: TBody;
+    noHeaders?: boolean;
+    controller?: AbortController;
+    query?: Record<string, string | undefined>;
+    baseEndpoint?: string;
+};
+export type ApiUtilOptions = {
+    baseEndpointDev: string;
+    baseEndpoint?: string;
+    log?: boolean;
+};

package/dist/Utils/ApiUtils/ApiTypes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// All possible endpoints for the API. This will generate autocomplete when using the Request function
+// The commented code below is an example from my previous "CitizenTaxi" project to illustrate how this works
+// export type ApiEndpoints<Param extends TParam = undefined> =
+//   | `bookings` // [GET, POST]
+//   | `bookings?citizenId=${Param}` // [GET] Guid
+//   | `bookings/${Param}` // [GET, PUT, DELETE] Guid bookingId
+//   | `notes` // [GET, POST]
+//   | `notes?citizenId=${Param}` // [GET] Guid
+//   | `notes/${Param}` // [GET, PUT, DELETE] Guid noteId
+//   | `users` // [GET, POST]
+//   | `users?role=${Param}` // [GET] enum Role
+//   | `users/${Param}` // [GET, PUT, DELETE] Guid userId
+//   | `users/authenticate`; // [POST, DELETE]

package/dist/Utils/ApiUtils/RequestUtil.d.ts

@@ -0,0 +1,19 @@
+import { RequestOptions } from "./ApiTypes";
+/**
+ * Makes a request to the API
+ * @param path Api endpoint to request
+ * @param options Additional options for the request
+ * @returns The response from the API
+ */
+export declare function Request<TData, ApiEndpoints extends string>(path: ApiEndpoints, { method, body, noHeaders, controller, query, baseEndpoint }?: RequestOptions | undefined, log?: boolean): Promise<{
+    success: boolean;
+    status: number;
+    data: TData;
+    text: string;
+}>;
+/**
+ * Ensures that the path starts with a /
+ * @param path Path string
+ * @returns Path that starts with a /
+ */
+export declare function ensureSlash(path: string): string;

package/dist/Utils/ApiUtils/RequestUtil.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureSlash = exports.Request = void 0;
+/**
+ * Makes a request to the API
+ * @param path Api endpoint to request
+ * @param options Additional options for the request
+ * @returns The response from the API
+ */
+async function Request(path, 
+// Destructor the options object, if it's undefined then set it to an empty object
+{ method = 'GET', body, noHeaders = false, controller = new AbortController(), query, baseEndpoint } = {}, log = false) {
+    // console.log(`Requesting ${path} with method ${method}`);
+    // Construct the endpoint for the request
+    const endpoint = (() => {
+        const result = baseEndpoint + ensureSlash(path);
+        if (path.includes('?') || !query)
+            return result;
+        // If the query object is defined, then construct a query string from it
+        const queryString = Object.entries(query)
+            .map(([key, value]) => value ? `${key}=${value}` : '')
+            .join('&');
+        return path.includes('?') ? `${result}&${queryString}` : `${result}?${queryString}`;
+    })();
+    // Construct the request init object to pass to the fetch function
+    const init = {
+        method,
+        body: body ? !noHeaders ? JSON.stringify(body) : body : undefined,
+        headers: !noHeaders ? { 'Content-Type': 'application/json' } : undefined,
+        signal: controller.signal,
+        credentials: 'include',
+        mode: 'cors'
+    };
+    // Make the request, log any errors, and throw them again
+    const res = await fetch(endpoint, init).catch(err => {
+        console.error(`Failed to [${method}] ${path}`, err);
+        throw err;
+    });
+    if (log)
+        console.log(`[${method}] ${path} responded with ${res.status}`, res);
+    // Clone the response so that it can be converted to JSON and text
+    const clone = res.clone();
+    // All successful responses are in the 200s, so check if the status code starts with 2
+    const isSuccessful = res.status.toString().startsWith('2');
+    // This try-catch block is used to catch any errors when converting the response to JSON
+    // If the response is not jsonable, then the catch will return null for the data
+    try {
+        return {
+            success: isSuccessful,
+            status: res.status,
+            data: await res.json(),
+            text: await clone.text(),
+        };
+    }
+    catch {
+        return {
+            success: isSuccessful,
+            status: res.status,
+            data: null,
+            text: await clone.text(),
+        };
+    }
+}
+exports.Request = Request;
+/**
+ * Ensures that the path starts with a /
+ * @param path Path string
+ * @returns Path that starts with a /
+ */
+function ensureSlash(path) {
+    return path.startsWith('/') ? path : '/' + path;
+}
+exports.ensureSlash = ensureSlash;

package/dist/Utils/ApiUtils/index.d.ts

@@ -0,0 +1,20 @@
+import { ApiUtilOptions, RequestOptions } from "./ApiTypes";
+export declare class ApiUtils<ApiEndpoints extends string> {
+    protected __baseEndpointDev: string;
+    protected __baseEndpoint?: string;
+    protected __log: boolean;
+    constructor({ baseEndpointDev, baseEndpoint, log }: ApiUtilOptions);
+    /**
+     * Make a request to the API
+     * @param path The path to the endpoint
+     * @param options The options for the request
+     * @returns The response from the API
+     */
+    request<TData>(path: ApiEndpoints, options?: RequestOptions): Promise<{
+        success: boolean;
+        status: number;
+        data: TData;
+        text: string;
+    }>;
+    get baseEndpoint(): string;
+}

package/dist/Utils/ApiUtils/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiUtils = void 0;
+const RequestUtil_1 = require("./RequestUtil");
+class ApiUtils {
+    __baseEndpointDev;
+    __baseEndpoint;
+    __log;
+    constructor({ baseEndpointDev, baseEndpoint, log }) {
+        this.__baseEndpointDev = baseEndpointDev;
+        this.__baseEndpoint = baseEndpoint;
+        this.__log = log ?? false;
+    }
+    /**
+     * Make a request to the API
+     * @param path The path to the endpoint
+     * @param options The options for the request
+     * @returns The response from the API
+     */
+    async request(path, options) {
+        return (0, RequestUtil_1.Request)(path, {
+            ...options,
+            baseEndpoint: this.baseEndpoint
+        }, this.__log);
+    }
+    get baseEndpoint() {
+        const processExists = 'process' in globalThis;
+        // @ts-ignore -- process is not defined in the browser
+        const isDev = processExists && process.env.NODE_ENV === 'development';
+        return isDev ? this.__baseEndpointDev : this.__baseEndpoint ?? this.__baseEndpointDev;
+    }
+}
+exports.ApiUtils = ApiUtils;

package/dist/Utils/ColorUtils.d.ts

@@ -0,0 +1,11 @@
+export type RGB = [number, number, number];
+export type Hex = `#${string}`;
+export type ColorType = 'hex' | 'rgb' | 'hsl';
+export declare function convert(value: RGB, to: Exclude<ColorType, 'rgb'>): string;
+export declare function convert(value: string, from: Exclude<ColorType, 'rgb'>, to: 'rgb'): RGB;
+export declare function generateRandomColor(): Hex;
+export declare const ColorUtils: {
+    convert: typeof convert;
+    generateRandomColor: typeof generateRandomColor;
+};
+export default ColorUtils;

package/dist/Utils/ColorUtils.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorUtils = exports.generateRandomColor = exports.convert = void 0;
+function convert(value, fromOrTo, to) {
+    const from = typeof value === 'string' ? fromOrTo : 'rgb';
+    const target = typeof value === 'string' ? to : fromOrTo;
+    if (from === target)
+        return value;
+    switch (from) {
+        case 'hsl': {
+            switch (target) {
+                case 'hex': return hslToHex(value);
+                case 'rgb': return hexToRgb(hslToHex(value));
+            }
+        }
+        case 'rgb': {
+            switch (target) {
+                case 'hex': return hslToHex(rgbToHsl(value));
+                case 'hsl': return rgbToHsl(value);
+            }
+        }
+        case 'hex': {
+            switch (target) {
+                case 'rgb': return hexToRgb(value);
+                case 'hsl': return rgbToHsl(hexToRgb(value));
+            }
+        }
+        default: return value;
+    }
+}
+exports.convert = convert;
+function generateRandomColor() {
+    return `#${Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0')}`;
+}
+exports.generateRandomColor = generateRandomColor;
+exports.ColorUtils = {
+    convert,
+    generateRandomColor
+};
+exports.default = exports.ColorUtils;
+function hslToHex(value) {
+    if (!value)
+        return "#000000";
+    const match = value.match(/hsl\((\d+), (\d+)%, (\d+)%\)/);
+    if (!match)
+        return value;
+    let [_, h, s, l] = match.map(Number);
+    l /= 100;
+    const a = s * Math.min(l, 1 - l) / 100;
+    const format = (value) => {
+        const k = (value + h / 30) % 12;
+        const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0');
+    };
+    return `#${format(0)}${format(8)}${format(4)}`;
+}
+function hexToRgb(hex) {
+    if (!hex)
+        return [0, 0, 0];
+    const match = hex.match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+    if (!match)
+        return [0, 0, 0];
+    let colorString = match[0];
+    if (match[0].length === 3)
+        colorString = colorString.split('').map(char => char + char).join('');
+    const integer = parseInt(colorString, 16);
+    const r = (integer >> 16) & 0xFF;
+    const g = (integer >> 8) & 0xFF;
+    const b = integer & 0xFF;
+    return [r, g, b];
+}
+function rgbToHsl(rgb) {
+    let [r, g, b] = rgb.map(x => x / 255);
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0, l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    return `hsl(${Math.round(h * 360)}, ${Math.round(s * 100)}%, ${Math.round(l * 100)}%)`;
+}

package/dist/Utils/FormUtil.d.ts

@@ -1,6 +1,6 @@
-/**
- * Serialize a form into an object
- * @param form The form to serialize
- * @returns An object of type T from the form
- */
-export declare function serializeForm<T extends object>(form: HTMLFormElement, log?: boolean): T;
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+export declare function serializeForm<T extends object>(form: HTMLFormElement, log?: boolean): T;

package/dist/Utils/FormUtil.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeForm = void 0;
-/**
- * Serialize a form into an object
- * @param form The form to serialize
- * @returns An object of type T from the form
- */
-function serializeForm(form, log = false) {
-    const children = Array.from(form.children);
-    const formData = children.reduce((acc, child) => {
-        // Find inputs and selects
-        const elements = Array.from(child.querySelectorAll('input, select'));
-        if (['INPUT', 'SELECT'].includes(child.tagName))
-            elements.push(child);
-        for (const element of Array.from(elements)) {
-            if (element.type === 'submit')
-                continue; // Ignore submit buttons
-            const name = element.getAttribute('name');
-            if (!name) {
-                console.error('[DanhoLibraryRJS] [FormUtil]: name attribute is required', { element });
-                throw new Error('name attribute is required');
-            }
-            const value = element.value;
-            if (value === null)
-                console.warn(`${name}.value returned null`, { element });
-            if (log)
-                console.log(`[DanhoLibraryRJS] [FormUtil]`, { name, value });
-            acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
-        }
-        return acc;
-    }, {});
-    return formData;
-}
-exports.serializeForm = serializeForm;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForm = void 0;
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+function serializeForm(form, log = false) {
+    const children = Array.from(form.children);
+    const formData = children.reduce((acc, child) => {
+        // Find inputs and selects
+        const elements = Array.from(child.querySelectorAll('input, select'));
+        if (['INPUT', 'SELECT'].includes(child.tagName))
+            elements.push(child);
+        for (const element of Array.from(elements)) {
+            if (element.type === 'submit')
+                continue; // Ignore submit buttons
+            const name = element.getAttribute('name');
+            if (!name) {
+                console.error('[DanhoLibraryRJS] [FormUtil]: name attribute is required', { element });
+                throw new Error('name attribute is required');
+            }
+            const value = element.value;
+            if (value === null)
+                console.warn(`${name}.value returned null`, { element });
+            if (log)
+                console.log(`[DanhoLibraryRJS] [FormUtil]`, { name, value });
+            acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
+        }
+        return acc;
+    }, {});
+    return formData;
+}
+exports.serializeForm = serializeForm;

package/dist/Utils/FormUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+export declare function serializeForm<T extends object>(form: HTMLFormElement, log?: boolean): T;

package/dist/Utils/FormUtils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForm = void 0;
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+function serializeForm(form, log = false) {
+    const children = Array.from(form.children);
+    const formData = children.reduce((acc, child) => {
+        // Find inputs and selects
+        const elements = Array.from(child.querySelectorAll('input, select'));
+        if (['INPUT', 'SELECT'].includes(child.tagName))
+            elements.push(child);
+        for (const element of Array.from(elements)) {
+            if (element.type === 'submit')
+                continue; // Ignore submit buttons
+            const name = element.getAttribute('name');
+            if (!name) {
+                console.error('[DanhoLibraryJS] [FormUtil]: name attribute is required', { element });
+                throw new Error('name attribute is required');
+            }
+            const value = element.value;
+            if (value === null)
+                console.warn(`${name}.value returned null`, { element });
+            if (log)
+                console.log(`[DanhoLibraryJS] [FormUtil]`, { name, value });
+            acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
+        }
+        return acc;
+    }, {});
+    return formData;
+}
+exports.serializeForm = serializeForm;

package/dist/Utils/NumberUtils.d.ts

@@ -0,0 +1 @@
+export declare function between(min: number, max: number): number;

package/dist/Utils/NumberUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.between = void 0;
+function between(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+exports.between = between;

package/dist/Utils/PatcherUtils.d.ts

@@ -0,0 +1,6 @@
+type PatchEvent = 'before' | 'instead' | 'after';
+type PatcherReplacement<TTarget extends object, TProperty extends keyof TTarget, TPatchEvent extends PatchEvent> = (TPatchEvent extends 'before' ? TTarget[TProperty] extends (...args: infer TArgs) => any ? (...args: TArgs) => TArgs | void : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty] | void : TPatchEvent extends 'instead' ? TTarget[TProperty] extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty] : TTarget[TProperty] extends (...args: infer TArgs) => any ? (...args: TArgs) => void : (previous: TTarget[TProperty], updated: TTarget[TProperty]) => void);
+export declare function patch<TTarget extends object, TProperty extends keyof TTarget, TPatchEvent extends PatchEvent, TPatchReplacement extends PatcherReplacement<TTarget, TProperty, TPatchEvent>>(target: TTarget, property: TProperty, event: TPatchEvent, replacement: TPatchReplacement): (() => TTarget[TProperty] & Function) | (() => TTarget) | undefined;
+export declare function unpatch<TTarget extends object, TProperty extends keyof TTarget>(target: TTarget, property: TProperty): void;
+export declare function unpatchAll(): void;
+export {};

package/dist/Utils/PatcherUtils.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpatchAll = exports.unpatch = exports.patch = void 0;
+const PATCHES = new Map();
+function patch(target, property, event, replacement) {
+    if (!target || !property || !replacement)
+        return;
+    else if (!(property in target))
+        throw Error(`Property "${String(property)}" does not exist on target`);
+    const original = target[property];
+    if (!PATCHES.has(target))
+        PATCHES.set(target, new Map());
+    const targetPatches = PATCHES.get(target);
+    if (!targetPatches.has(property))
+        targetPatches.set(property, []);
+    const unpatch = (() => {
+        if (typeof original === 'function') {
+            switch (event) {
+                case 'before': {
+                    target[property] = function (...args) {
+                        const updatedArgs = replacement.apply(target, args);
+                        return original.apply(target, updatedArgs || args);
+                    };
+                    break;
+                }
+                case 'instead': {
+                    target[property] = function (...args) {
+                        return replacement.apply(target, args);
+                    };
+                    break;
+                }
+                case 'after': {
+                    target[property] = function (...args) {
+                        const result = original.apply(target, args);
+                        replacement.apply(target, args);
+                        return result;
+                    };
+                    break;
+                }
+            }
+            return () => target[property] = original;
+        }
+        else {
+            let currentValue = target[property];
+            const propertyDescriptor = Object.getOwnPropertyDescriptor(target, property);
+            const valuePatch = (update) => {
+                update ??= currentValue;
+                const result = event !== 'after' ? replacement(currentValue, update) || currentValue : currentValue;
+                if (event === 'after')
+                    replacement(currentValue, update);
+                return result;
+            };
+            Object.defineProperty(target, property, {
+                get: () => valuePatch(),
+                set: valuePatch,
+            });
+            return () => Object.defineProperty(target, property, propertyDescriptor);
+        }
+    })();
+    targetPatches.get(property).push({ event, replacement, original, unpatch });
+    return unpatch;
+}
+exports.patch = patch;
+function unpatch(target, property) {
+    const targetPatches = PATCHES.get(target);
+    if (!targetPatches?.has(property))
+        return;
+    targetPatches.get(property).forEach(patch => patch.unpatch());
+    targetPatches.delete(property);
+}
+exports.unpatch = unpatch;
+function unpatchAll() {
+    PATCHES.forEach(properties => {
+        properties.forEach(patches => {
+            patches.forEach(patch => patch.unpatch());
+        });
+    });
+    PATCHES.clear();
+}
+exports.unpatchAll = unpatchAll;

package/dist/Utils/StringUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function classNames(...args: Array<any>): string;
+export declare function randomId(length?: number): string;
+export declare function pluralize(countable: number | ArrayLike<any> | Map<any, any>, singular: string, plural?: string): string;