danholibraryjs 1.10.0 → 2.0.0

package/dist/Extensions/index.js

@@ -14,17 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BooleanExtensions = void 0;
 __exportStar(require("./Array"), exports);
 __exportStar(require("./Document"), exports);
 __exportStar(require("./Map"), exports);
 __exportStar(require("./Object"), exports);
+__exportStar(require("./Number"), exports);
 __exportStar(require("./String"), exports);
-function parseBoolean(value) {
-    return value === "true";
-}
-;
-Boolean.parseBoolean = parseBoolean;
-exports.BooleanExtensions = {
-    parseBoolean
-};

package/dist/Types/Able.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Item is function or T
+ */
+export type Functionable<T, Args extends any[] = []> = T | ((...args: Args) => T);
+/**
+ * Item is Promise<T> or T
+ */
+export type Promisable<T> = T | Promise<T>;
+/**
+ * Item is T or null
+ */
+export type Nullable<T> = T | null;
+/**
+ * Item cannot be null or undefined
+ */
+export type NonNullable<T> = T extends null ? never : T extends undefined ? never : T;

package/dist/Types/Able.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/Array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Item is single or multiple
+ */
+export type Arrayable<T> = T | Array<T>;
+export type SingleArrayable<T> = T | [T];
+export type TFromArray<T> = T extends Array<infer U> ? U : never;

package/dist/Types/Array.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/C#.d.ts

@@ -0,0 +1,8 @@
+/**
+ * C# Guid representation
+ */
+export type Guid = string;
+/**
+ * C# TimeSpan representation from JSON
+ */
+export type TimeSpanType = string;

package/dist/Types/C#.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/Date.d.ts

@@ -1,4 +1,4 @@
-export type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+export type LongMonth = 'January' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
 export type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
 export type Month = LongMonth | ShortMonth;
 export type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';

package/dist/Types/Events.d.ts

@@ -1,9 +1,9 @@
 /**
- * Default eventhandler mapper. Object with properties that are arrays
+ * Default event-handler mapper. Object with properties that are arrays
  */
 export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
 /**
- * Eventhandler type for:
+ * Event-handler type for:
  * @see EventCollection
  * @borrows BaseEvent
  */

package/dist/Types/Function.d.ts

@@ -0,0 +1,5 @@
+export type NewReturnType<Function extends (...args: any[]) => any, NewReturnType extends any> = (...args: Parameters<Function>) => NewReturnType;
+export type PromisedReturn<Function extends (...args: any[]) => any> = NewReturnType<Function, Promise<ReturnType<Function>>>;
+export type NoFunctions<T> = {
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+};

package/dist/Types/Function.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/Object.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Return types of T
+ */
+export type ValueOf<T> = T[keyof T];

package/dist/Types/Object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/PropertiesWith.d.ts

@@ -11,3 +11,24 @@ export default PropertiesWith;
 export type PropertiesWithout<Type, From> = {
     [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
 };
+/**
+ * GetRepeatedKeys<[
+ *  { username: string, password: string },
+ *  { username: number, email: string },
+ * ]> // { username: string | number }
+ */
+export type GetRepeatedKeys<Types extends Array<any>> = (Types extends [infer First, infer Second, ...infer Rest] ? First extends object ? Second extends object ? {
+    [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key];
+} & GetRepeatedKeys<Rest> : {} : {} : {});
+/**
+ * Situation: Model = Character | Artifact | Domain
+ * Type must include generic type T, which is the Model type
+ * Type must also include generic type TProps, which is the properties of the Model type. Selected properties of TProps must extract the types of Model whose properties has been selected.
+ *
+ * Example:
+ * type Model = Character | Artifact | Domain
+ * Properties<Model, 'name' | 'rarity'>
+ *
+ * Result: Character | Artifact, because only Character and Artifact have 'name' and 'rarity' properties
+ */
+export type ModelWithProps<T, TProps extends (keyof T | string)> = T extends Record<TProps, any> ? T : never;

package/dist/Types/String.d.ts

@@ -0,0 +1 @@
+export type Autocomplete<T> = T | (string & {});

package/dist/Types/String.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/TransformTypes.d.ts

@@ -10,4 +10,13 @@ export type TransformType<From, Start, Switch> = {
 export type TransformTypes<From, BaseType, NewType> = Record<keyof {
     [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
 }, NewType>;
+export type Json<T> = {
+    [Key in keyof T]: T[Key] extends object ? Json<T[Key]> : T[Key] extends Array<infer U> ? Array<Json<U>> : T[Key] extends number | string | boolean | null ? T[Key] : string;
+};
+/**
+ * Type's properties are ReturnType
+ */
+export type AllPropsAre<ReturnType> = {
+    [key: string]: ReturnType;
+};
 export default TransformTypes;

package/dist/Types/index.d.ts

@@ -1,17 +1,14 @@
+export * from './Able';
+export * from './Array';
 export * from './BetterTypes';
+export * from './C#';
 export * from './Date';
 export * from './Events';
+export * from './Function';
 export * from './TransformTypes';
+export * from './Object';
 export * from './PropertiesWith';
-/**
- * Item is single or multiple
- */
-export type Arrayable<T> = T | Array<T>;
-/**
- * Item is function or T
- */
-export type Functionable<T> = T | (() => T);
-
+export * from './String';
 /**
  * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
  * IElement accepts HTML Elements or HTMl-like strings.
@@ -20,27 +17,8 @@ export type Functionable<T> = T | (() => T);
  * @see Document.createElement
  */
 export type IElement = HTMLElement | string;
-/**
- * Return types of T
- */
-export type ValueOf<T> = T[keyof T];
-/**
- * Type's properties are ReturnType
- */
-export type AllPropsAre<ReturnType> = {
-    [key: string]: ReturnType;
-};
 /**
  * string or RegExp.. pretty self-explanatory
  */
 export type StringRegex = string | RegExp;
 export type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;
-/**
- * GetRepeatedKeys<[
- *  { username: string, password: string },
- *  { username: number, email: string },
- * ]> // { username: string | number }
- */
-export type GetRepeatedKeys<Types extends Array<any>> = (Types extends [infer First, infer Second, ...infer Rest] ? First extends object ? Second extends object ? {
-    [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key];
-} & GetRepeatedKeys<Rest> : {} : {} : {});

package/dist/Types/index.js

@@ -14,8 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Able"), exports);
+__exportStar(require("./Array"), exports);
 __exportStar(require("./BetterTypes"), exports);
+__exportStar(require("./C#"), exports);
 __exportStar(require("./Date"), exports);
 __exportStar(require("./Events"), exports);
+__exportStar(require("./Function"), exports);
 __exportStar(require("./TransformTypes"), exports);
+__exportStar(require("./Object"), exports);
 __exportStar(require("./PropertiesWith"), exports);
+__exportStar(require("./String"), exports);

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

@@ -0,0 +1,15 @@
+export type TParam = string | undefined;
+export type HttpMethods = 'GET' | 'POST' | 'PUT' | '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/ApiUtil/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/ApiUtil/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/ApiUtil/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/ApiUtil/index.d.ts

@@ -0,0 +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;
+}

package/dist/Utils/ApiUtil/index.js

@@ -0,0 +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;

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;