@develia/commons 0.3.12 → 0.3.13

package/src/functions.ts

@@ -0,0 +1,247 @@
+// noinspection JSUnusedGlobalSymbols
+
+
+import Pair from "./pair";
+import {Nullable, Provider} from "./types";
+
+export function isIterable(obj: any): boolean {
+    return obj[Symbol.iterator] === 'function';
+}
+
+export function clamp(n: number, min: number, max: number) {
+    if (n <= min)
+        return min;
+    if (n >= max)
+        return max;
+    return n
+}
+
+/**
+ * Linearly remaps a value from its source range [`inMin`, `inMax`] to the destination range [`outMin`, `outMax`]
+ *
+ * @category Math
+ * @example
+ * ```
+ * const value = remap(0.5, 0, 1, 200, 400) // value will be 300
+ * ```
+ */
+export function lerp(n: number, inMin: number, inMax: number, outMin: number, outMax: number) {
+
+
+    return outMin + (outMax - outMin) * ((n - inMin) / (inMax - inMin))
+
+
+}
+
+
+/**
+ * Ensure prefix of a string
+ *
+ * @category String
+ */
+export function ensurePrefix(prefix: string, str: string) {
+    if (!str.startsWith(prefix))
+        return prefix + str
+    return str
+}
+
+/**
+ * Ensure suffix of a string
+ *
+ * @category String
+ */
+export function ensureSuffix(suffix: string, str: string) {
+    if (!str.endsWith(suffix))
+        return str + suffix
+    return str
+}
+
+export function isString(value: any): value is string {
+    return typeof value === 'string';
+}
+
+export function isNumber(value: any): value is number {
+    return typeof value === 'number';
+}
+
+export function isBoolean(value: any): value is boolean {
+    return typeof value === 'boolean';
+}
+
+export function isObject(value: any): value is object {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function isArray(value: any): value is any[] {
+    return Array.isArray(value);
+}
+
+export function isFunction(value: any): value is Function {
+    return typeof value === 'function';
+}
+
+export function isUndefined(value: any): value is undefined {
+    return typeof value === 'undefined';
+}
+
+export function isNull(value: any): value is null {
+    return value === null;
+}
+
+export function isBigInt(value: any): value is bigint {
+    return typeof value === 'bigint';
+}
+
+export function isSymbol(value: any): value is symbol {
+    return typeof value === 'symbol';
+}
+
+export function isNullOrUndefined(value: any) {
+    return value === null || typeof value === 'undefined';
+}
+
+export function isEmpty(value: any): boolean {
+    return (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'string' && value === '') ||
+        value === null || typeof value === 'undefined';
+}
+
+export function isEmptyOrWhitespace(value: any): boolean {
+    return (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'string' && value.trim() === '') ||
+        value === null || typeof value === 'undefined';
+}
+
+
+export async function ajaxSubmit(selectorOrElement: HTMLFormElement | string): Promise<Response> {
+
+    const form = typeof selectorOrElement === 'string'
+        ? document.querySelector(selectorOrElement)
+        : selectorOrElement;
+
+    if (!(form instanceof HTMLFormElement)) {
+        throw new Error("Invalid element.");
+    }
+
+    // Crear un objeto FormData a partir del formulario
+    return await fetch(form.action, {
+        method: form.method,
+        body: new FormData(form),
+    });
+}
+
+export function toPairs(obj: any): Pair<any, any>[] {
+
+    let output = [];
+    for (const key in obj) {
+        output.push(new Pair(key, obj[key]));
+    }
+    return output;
+
+}
+
+export function promisify<T>(thing: any): Promise<T> {
+
+    if (thing instanceof Promise)
+        return thing;
+
+
+    if (isFunction(thing)) {
+        return new Promise<T>((resolve, reject) => {
+            try {
+                const result = thing();
+                resolve(result);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    return Promise.resolve(thing);
+}
+
+export function ajaxSubmission(selectorOrElement: HTMLFormElement | string,
+                               onSuccess: Nullable<Provider<Nullable<any>>> = null,
+                               onFailure: Nullable<Provider<Nullable<any>>> = null) {
+
+    const form = typeof selectorOrElement === 'string'
+        ? document.querySelector(selectorOrElement)
+        : selectorOrElement;
+
+    if (!(form instanceof HTMLFormElement)) {
+        return;
+    }
+
+    form.addEventListener('submit', async (event) => {
+        event.preventDefault();
+        let promise = ajaxSubmit(form);
+        if (promise) {
+            if (onSuccess)
+                promise = promise.then(onSuccess);
+            if (onFailure)
+                promise.catch(onFailure);
+        }
+
+    });
+
+
+}
+
+
+export function deepClone<T>(obj: T): T {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+
+    if (Array.isArray(obj)) {
+        const copy: any[] = [];
+        for (const element of obj) {
+            copy.push(deepClone(element));
+        }
+        return copy as T;
+    }
+
+    const copy: { [key: string]: any } = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            copy[key] = deepClone((obj as { [key: string]: any })[key]);
+        }
+    }
+    return copy as T;
+}
+
+function _objectToFormData(data: Record<string, any>, formData: FormData, parentKey: string = ''): FormData {
+
+
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            const value = data[key];
+
+            if (value instanceof Date) {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value.toISOString());
+            } else if (value instanceof File) {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value);
+            } else if (typeof value === 'object' && !Array.isArray(value)) {
+                _objectToFormData(value, formData, parentKey ? `${parentKey}[${key}]` : key);
+            } else if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    const arrayKey = `${parentKey ? `${parentKey}[${key}]` : key}[${index}]`;
+                    if (typeof item === 'object' && !Array.isArray(item)) {
+                        _objectToFormData(item, formData, arrayKey);
+                    } else {
+                        formData.append(arrayKey, item);
+                    }
+                });
+            } else {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value);
+            }
+        }
+    }
+
+    return formData;
+}
+
+export function objectToFormData(data: Record<string, any>): FormData {
+    let formData = new FormData();
+    return _objectToFormData(data, formData);
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './functions';
+export {default as CacheDictionary} from './cache-dictionary';
+export {default as from, From} from './from';
+export * from './types';
+export {default as Timer} from './timer'
+export {default as TimeSpan} from './timespan'
+export {default as Lazy} from './lazy'
+export {default as Pair} from './pair'
+
+
+

package/src/lazy.ts

@@ -0,0 +1,32 @@
+import {promisify} from "./functions";
+import {Nullable} from "./types";
+
+
+type FactoryMethod<T> = Promise<Nullable<T>> | (() => (Promise<Nullable<T>> | Nullable<T>));
+
+export default class Lazy<T> {
+    private _valueCreated = false;
+    private _value: Nullable<T> = null;
+    private readonly _factoryMethod: FactoryMethod<T>;
+
+    constructor(getter: FactoryMethod<T>) {
+        this._factoryMethod = getter;
+    }
+
+    get valueCreated(): boolean {
+        return this._valueCreated;
+    }
+
+    async getValue(): Promise<Nullable<T>> {
+        if (!this._valueCreated) {
+            this._value = await promisify(this._factoryMethod);
+            this._valueCreated = true;
+        }
+        return this._value;
+    }
+
+    reset(): void {
+        this._valueCreated = false;
+        this._value = null;
+    }
+}

package/src/pair.ts

@@ -0,0 +1,19 @@
+export default class Pair<TKey, TValue> {
+    get value(): TValue {
+        return this._value;
+    }
+
+    get key(): TKey {
+        return this._key;
+    }
+
+    private readonly _key: TKey;
+    private readonly _value: TValue;
+
+    constructor(key: TKey, value: TValue) {
+        this._key = key;
+        this._value = value;
+    }
+
+
+}

package/src/timer.ts

@@ -0,0 +1,65 @@
+export default class Timer {
+
+    private _callback: () => void;
+    private _interval: number;
+    private _intervalId: any | null;
+
+    /**
+     * @param callback Callback
+     * @param interval Seconds between calls
+     */
+    constructor(callback: () => void, interval: number) {
+        this._callback = callback;
+        this._interval = interval;
+        this._intervalId = null;
+    }
+
+    
+    get running(): boolean {
+        return this._intervalId !== null && this._intervalId !== undefined;
+    }
+
+    get interval(): number {
+        return this._interval;
+    }
+
+    set interval(value: number) {
+        if (value != this._interval) {
+            this._interval = value;
+            if (this.running)
+                this.restart();
+        }
+    }
+
+    get callback(): () => void {
+        return this._callback;
+    }
+
+    set callback(value: () => void) {
+        if (value != this._callback) {
+            this._callback = value;
+        }
+    }
+
+
+    start(): void {
+        if (this._intervalId === null) {
+            this._intervalId = setInterval(() => {
+                if (this._callback != null)
+                    this._callback();
+            }, this._interval);
+        }
+    }
+
+    stop(): void {
+        if (this._intervalId !== null) {
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+
+    restart(): void {
+        this.stop();
+        this.start();
+    }
+}

package/src/timespan.ts

@@ -0,0 +1,217 @@
+export default class TimeSpan {
+    public milliseconds: number;
+
+    private constructor(milliseconds: number) {
+        this.milliseconds = milliseconds;
+    }
+
+
+    // Obtener el intervalo de tiempo en segundos
+    seconds(): number {
+        return this.milliseconds / 1000;
+    }
+
+    // Obtener el intervalo de tiempo en minutos
+    minutes(): number {
+        return this.milliseconds / (1000 * 60);
+    }
+
+    // Obtener el intervalo de tiempo en horas
+    hours(): number {
+        return this.milliseconds / (1000 * 60 * 60);
+    }
+
+    // Obtener el intervalo de tiempo en días
+    days(): number {
+        return this.milliseconds / (1000 * 60 * 60 * 24);
+    }
+
+    // Obtener el intervalo de tiempo en semanas
+    weeks(): number {
+        return this.milliseconds / (1000 * 60 * 60 * 24 * 7);
+    }
+
+    // Constructor estático para crear un TimeSpan desde milisegundos
+    static fromMilliseconds(milliseconds: number): TimeSpan {
+        return new TimeSpan(milliseconds);
+    }
+
+    // Constructor estático para crear un TimeSpan desde segundos
+    static fromSeconds(seconds: number): TimeSpan {
+        return new TimeSpan(seconds * 1000);
+    }
+
+    // Constructor estático para crear un TimeSpan desde minutos
+    static fromMinutes(minutes: number): TimeSpan {
+        return new TimeSpan(minutes * 1000 * 60);
+    }
+
+    // Constructor estático para crear un TimeSpan desde horas
+    static fromHours(hours: number): TimeSpan {
+        return new TimeSpan(hours * 1000 * 60 * 60);
+    }
+
+    // Constructor estático para crear un TimeSpan desde días
+    static fromDays(days: number): TimeSpan {
+        return new TimeSpan(days * 1000 * 60 * 60 * 24);
+    }
+
+    // Constructor estático para crear un TimeSpan desde semanas
+    static fromWeeks(weeks: number): TimeSpan {
+        return new TimeSpan(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+
+    // Añadir un intervalo de tiempo
+    addMilliseconds(milliseconds: number): TimeSpan {
+        return new TimeSpan(this.milliseconds + milliseconds);
+    }
+
+    addSeconds(seconds: number): TimeSpan {
+        return this.addMilliseconds(seconds * 1000);
+    }
+
+    addMinutes(minutes: number): TimeSpan {
+        return this.addMilliseconds(minutes * 1000 * 60);
+    }
+
+    addHours(hours: number): TimeSpan {
+        return this.addMilliseconds(hours * 1000 * 60 * 60);
+    }
+
+    addDays(days: number): TimeSpan {
+        return this.addMilliseconds(days * 1000 * 60 * 60 * 24);
+    }
+
+    addWeeks(weeks: number): TimeSpan {
+        return this.addMilliseconds(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+
+    // Restar un intervalo de tiempo
+    subtractMilliseconds(milliseconds: number): TimeSpan {
+        return new TimeSpan(this.milliseconds - milliseconds);
+    }
+
+    subtractSeconds(seconds: number): TimeSpan {
+        return this.subtractMilliseconds(seconds * 1000);
+    }
+
+    subtractMinutes(minutes: number): TimeSpan {
+        return this.subtractMilliseconds(minutes * 1000 * 60);
+    }
+
+    subtractHours(hours: number): TimeSpan {
+        return this.subtractMilliseconds(hours * 1000 * 60 * 60);
+    }
+
+    subtractDays(days: number): TimeSpan {
+        return this.subtractMilliseconds(days * 1000 * 60 * 60 * 24);
+    }
+
+    subtractWeeks(weeks: number): TimeSpan {
+        return this.subtractMilliseconds(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+
+    // Añadir otro TimeSpan
+    add(other: TimeSpan): TimeSpan {
+        return new TimeSpan(this.milliseconds + other.milliseconds);
+    }
+
+    // Restar otro TimeSpan
+    subtract(other: TimeSpan): TimeSpan {
+        return new TimeSpan(this.milliseconds - other.milliseconds);
+    }
+
+    // Añadir un intervalo de tiempo a una fecha
+    addTo(date: Date): Date {
+        return new Date(date.getTime() + this.milliseconds);
+    }
+
+    // Restar un intervalo de tiempo de una fecha
+    subtractFrom(date: Date): Date {
+        return new Date(date.getTime() - this.milliseconds);
+    }
+
+
+    static fromDifference(earlierDate: Date, laterDate: Date): TimeSpan {
+        return new TimeSpan(laterDate.getTime() - earlierDate.getTime());
+    }
+
+    format(format: string = 'hh:mm:ss'): string {
+        const formatLower = format.toLowerCase();
+        const hasHours = formatLower.includes("h");
+        const hasMinutes = formatLower.includes("m");
+
+        let hours = 0, minutes = 0, seconds = Math.floor(this.milliseconds / 1000);
+
+        if (hasHours) {
+            hours = Math.floor(seconds / 3600);
+            seconds -= hours * 3600;
+        }
+        if (hasMinutes) {
+            minutes = Math.floor(seconds / 60);
+            seconds -= minutes * 60;
+        }
+
+        const hoursPadded = String(hours).padStart(2, '0');
+        const minutesPadded = String(minutes).padStart(2, '0');
+        const secondsPadded = String(seconds).padStart(2, '0');
+
+        return formatLower
+            .replace('hh', hoursPadded)
+            .replace('h', hours.toString())
+            .replace('mm', minutesPadded)
+            .replace('m', minutes.toString())
+            .replace('ss', secondsPadded)
+            .replace('s', seconds.toString());
+    }
+
+    eq(other: TimeSpan): boolean {
+        return this.milliseconds === other.milliseconds;
+    }
+
+    le(other: TimeSpan): boolean {
+        return this.milliseconds <= other.milliseconds;
+    }
+
+    lt(other: TimeSpan): boolean {
+        return this.milliseconds < other.milliseconds;
+    }
+
+    ge(other: TimeSpan): boolean {
+        return this.milliseconds >= other.milliseconds;
+    }
+
+    gt(other: TimeSpan): boolean {
+        return this.milliseconds > other.milliseconds;
+    }
+
+    multiply(number: number): TimeSpan {
+        return new TimeSpan(this.milliseconds * number);
+    }
+
+    divide(number: number): TimeSpan {
+        return new TimeSpan(this.milliseconds / number);
+    }
+
+    abs(): TimeSpan {
+        return new TimeSpan(Math.abs(this.milliseconds));
+    }
+
+    static readonly INFINITE = new TimeSpan(Number.POSITIVE_INFINITY);
+
+    static readonly NEGATIVE_INFINITE = new TimeSpan(Number.NEGATIVE_INFINITY);
+
+    isInfinite() {
+        return this.milliseconds === Number.POSITIVE_INFINITY || this.milliseconds === Number.NEGATIVE_INFINITY
+    }
+
+    // Determinar si es un TimeSpan infinitamente positivo
+    isPositiveInfinite(): boolean {
+        return this.milliseconds === Number.POSITIVE_INFINITY;
+    }
+
+    // Determinar si es un TimeSpan infinitamente negativo
+    isNegativeInfinite(): boolean {
+        return this.milliseconds === Number.NEGATIVE_INFINITY;
+    }
+}

package/src/types.ts

@@ -0,0 +1,14 @@
+export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
+
+export type UnaryFunction<T, R> = (arg: T) => R;
+
+export type Consumer<T> = (arg: T) => void
+
+export type Predicate<T> = (arg: T) => boolean;
+
+export type Provider<T> = () => T;
+
+export type Nullable<T> = T | null;
+
+export type Deferred<T> = Promise<T> | Provider<T>
+