@develia/commons 0.3.44 → 0.4.1

package/src/patch.ts

@@ -0,0 +1,80 @@
+import type {AbstractConstructor} from "./types.js";
+
+export type PureMethod<T extends object, A extends any[] = any[], R = any> =
+    (obj: T, ...args: A) => R;
+
+export type PatchSpec<T extends object> =
+    | Record<string, PureMethod<T, any[], any>>
+    | Map<PropertyKey, PureMethod<T, any[], any>>;
+
+
+export function patch<C extends AbstractConstructor<any>>(
+    targetOrCtor: C,
+    fns: PatchSpec<InstanceType<C>>
+): Map<PropertyKey, PropertyDescriptor | null>;
+
+export function patch<T extends object>(
+    targetOrCtor: T,
+    fns: PatchSpec<T>
+): Map<PropertyKey, PropertyDescriptor | null>;
+
+/**
+ * Devuelve un Map donde:
+ *  - clave -> null    (método añadido nuevo)
+ *  - clave -> descriptorOriginal (método sustituido)
+ */
+export function patch(
+    targetOrCtor: any,
+    fns: PatchSpec<any>
+): Map<PropertyKey, PropertyDescriptor | null> {
+    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
+
+    const result = new Map<PropertyKey, PropertyDescriptor | null>();
+    const entries: Array<[PropertyKey, PureMethod<any>]> =
+        fns instanceof Map ? [...fns.entries()] : Object.entries(fns) as any;
+
+    for (const [key, fn] of entries) {
+        const prev = Object.getOwnPropertyDescriptor(target, key);
+        const method = function (this: unknown, ...args: unknown[]) {
+            return (fn as any)(this, ...args);
+        };
+        try {
+            Object.defineProperty(target, key, {
+                value: method,
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            });
+            result.set(key, prev ?? null);
+        } catch { /* ignorar */
+        }
+    }
+    return result;
+}
+
+// Overloads unpatch
+export function unpatch<C extends AbstractConstructor<any>>(
+    targetOrCtor: C,
+    changes: Map<PropertyKey, PropertyDescriptor | null>
+): void;
+export function unpatch<T extends object>(
+    targetOrCtor: T,
+    changes: Map<PropertyKey, PropertyDescriptor | null>
+): void;
+
+/**
+ * Revierte un patch a partir del mapa devuelto por `patch`.
+ */
+export function unpatch(targetOrCtor: any, changes: Map<PropertyKey, PropertyDescriptor | null>): void {
+    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
+    for (const [key, prev] of changes) {
+        try {
+            if (prev === null) {
+                if (Object.prototype.hasOwnProperty.call(target, key)) delete target[key];
+            } else {
+                Object.defineProperty(target, key, prev);
+            }
+        } catch { /* ignorar */
+        }
+    }
+}

package/src/remote-data.ts

@@ -0,0 +1,149 @@
+export interface RemoteDataOptions<T = unknown> {
+    /** Opciones nativas de fetch (headers, method, body, signal, etc.) */
+    fetchOptions?: RequestInit;
+    /** Función para transformar la respuesta antes de almacenarla */
+    transform?: (raw: unknown) => T;
+    /** Tiempo máximo de espera en ms */
+    timeout?: number;
+    /** Número de reintentos ante fallo (por defecto: 0) */
+    retries?: number;
+    /** Delay entre reintentos en ms (por defecto: 1000) */
+    retryDelay?: number;
+    /** Datos iniciales (evita el primer fetch si se proporcionan) */
+    initialData?: T;
+}
+
+export default class RemoteData<T = unknown> {
+    _loaded: boolean = false;
+    _loading: boolean = false;
+    _data: T | null = null;
+    _url: string;
+    _error: Error | null = null;
+    _promise: Promise<T | null> | null = null;
+    _options: RemoteDataOptions<T>;
+
+    constructor(url: string, options: RemoteDataOptions<T> = {}) {
+        this._url = url;
+        this._options = options;
+
+        if (options.initialData !== undefined) {
+            this._data = options.initialData;
+            this._loaded = true;
+        }
+    }
+
+    get url(): string {
+        return this._url;
+    }
+
+    set url(value: string) {
+        if (this._url !== value) {
+            this._url = value;
+            this._loaded = false;
+        }
+    }
+
+    get loaded(): boolean {
+        return this._loaded;
+    }
+
+    get loading(): boolean {
+        return this._loading;
+    }
+
+    get error(): Error | null {
+        return this._error;
+    }
+
+    get succeeded(): boolean {
+        return this._loaded && !this._error;
+    }
+
+    get data(): T | null {
+        return this._data;
+    }
+
+    async getData(): Promise<T | null> {
+        if (!this._loaded) {
+            await this.refresh();
+        }
+        return this._data;
+    }
+
+    async refresh(): Promise<T | null> {
+        if (this._loading && this._promise) {
+            return this._promise;
+        }
+        this._promise = this._fetchWithRetries();
+        return this._promise;
+    }
+
+    reset(): void {
+        this._loaded = false;
+        this._loading = false;
+        this._data = null;
+        this._error = null;
+        this._promise = null;
+    }
+
+    // ── Internos ────────────────────────────────────────────────
+
+    async _fetchWithRetries(): Promise<T | null> {
+        const maxAttempts = (this._options.retries ?? 0) + 1;
+        const retryDelay = this._options.retryDelay ?? 1000;
+
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await this._doFetch();
+            } catch (error) {
+                if (attempt === maxAttempts) throw this._error;
+                await new Promise((r) => setTimeout(r, retryDelay));
+            }
+        }
+
+        return null; // unreachable, satisface al compilador
+    }
+
+    async _doFetch(): Promise<T | null> {
+        try {
+            this._error = null;
+            this._loading = true;
+
+            const fetchOptions = this._buildFetchOptions();
+            const response = await fetch(this._url, fetchOptions);
+
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+
+            const raw = await response.json();
+            this._data = this._options.transform
+                ? this._options.transform(raw)
+                : (raw as T);
+            this._loaded = true;
+
+            return this._data;
+        } catch (error) {
+            this._error = error instanceof Error
+                ? error
+                : new Error(String(error));
+            this._loaded = false;
+            throw this._error;
+        } finally {
+            this._loading = false;
+            this._promise = null;
+        }
+    }
+
+    _buildFetchOptions(): RequestInit {
+        const options: RequestInit = {...this._options.fetchOptions};
+
+        if (this._options.timeout && this._options.timeout > 0) {
+            const controller = new AbortController();
+            setTimeout(() => controller.abort(), this._options.timeout);
+            options.signal = controller.signal;
+        }
+
+        return options;
+    }
+}

package/src/stopwatch.ts

@@ -1,4 +1,4 @@
-import TimeSpan from "./timespan";
+import TimeSpan from "./timespan.js";
 
 export default class Stopwatch {
     private startTime: number | null = null;

package/src/{typing.ts → type.ts}

@@ -3,7 +3,7 @@
  * Represents different types in JavaScript.
  * @enum {string}
  */
-export enum Type {
+enum Type {
     Undefined = "undefined",
     Number = "number",
     String = "string",
@@ -15,3 +15,5 @@ export enum Type {
     Null = "null"
 }
 
+export default Type;
+

package/src/types.ts

@@ -1,6 +1,5 @@
 export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
 
-
 export type Consumer<T> = (arg: T) => void
 
 export type Predicate<T> = (arg: T) => boolean;
@@ -26,4 +25,8 @@ export type QuaternaryFunction<T1, T2, T3, T4, R> = (
     arg4: T4
 ) => R;
 
+export type Constructor<T = object, A extends any[] = any[]> =
+  new (...args: A) => T;
 
+export type AbstractConstructor<T = object, A extends any[] = any[]> =
+  abstract new (...args: A) => T;

package/src/utilities.ts

@@ -1,9 +1,9 @@
 // noinspection JSUnusedGlobalSymbols
 
 
-import KeyValuePair from "./key-value-pair";
-import {Optional, Resolvable, Supplier} from "./types";
-import {Type} from "./typing";
+import KeyValuePair from "./key-value-pair.js";
+import type {Optional, Resolvable, Supplier} from "./types.js";
+import Type from "./type.js";
 
 /**
  * Checks if an object is iterable.
@@ -454,24 +454,25 @@ export function getType(value: any): Type {
 }
 
 export function formToObject(form: HTMLFormElement): Record<string, FormDataEntryValue | FormDataEntryValue[]> {
-  const fd = new FormData(form);
-  const out: Record<string, FormDataEntryValue | FormDataEntryValue[]> = {};
-
-  for (const [key, value] of fd.entries()) {
-    if (key in out) {
-      const current = out[key];
-      if (Array.isArray(current)) {
-        current.push(value);
-      } else {
-        out[key] = [current, value];
-      }
-    } else {
-      out[key] = value;
+    const fd = new FormData(form);
+    const out: Record<string, FormDataEntryValue | FormDataEntryValue[]> = {};
+
+    for (const [key, value] of fd.entries()) {
+        if (key in out) {
+            const current = out[key];
+            if (Array.isArray(current)) {
+                current.push(value);
+            } else {
+                out[key] = [current, value];
+            }
+        } else {
+            out[key] = value;
+        }
     }
-  }
 
-  return out;
+    return out;
 }
+
 /**
  * Converts an object to `FormData` format recursively.
  *