@develia/commons 0.4.9 → 0.4.12

package/src/browser/geo-location.ts

@@ -1,80 +1,114 @@
-// ─── Tipos ───────────────────────────────────────────────
-
-export interface GeoLocation {
-    latitude: number;
-    longitude: number;
-    accuracy: number;          // metros
-    altitude: number | null;
-    altitudeAccuracy: number | null;
-    heading: number | null;    // grados desde el norte
-    speed: number | null;      // m/s
-    timestamp: number;
-}
-
-export interface GeoLocationOptions {
-    enableHighAccuracy?: boolean;  // GPS real vs torres/wifi
-    timeout?: number;              // ms máximo de espera
-    maximumAge?: number;           // ms cache válida
-}
-
-// ─── Función ─────────────────────────────────────────────
-
-export default async function getGeoLocation(options: GeoLocationOptions = {}): Promise<GeoLocation> {
-
-    // ── Soporte del navegador ────────────────────────────
-    if (!navigator.geolocation) {
-        throw new Error('Tu navegador no soporta geolocalización.');
-    }
-
-    // ── Comprobar permisos (API Permissions) ─────────────
-    if (navigator.permissions) {
-        const permission = await navigator.permissions.query({ name: 'geolocation' });
-
-        if (permission.state === 'denied') {
-            throw new Error(
-                'Permiso de ubicación denegado. Actívalo en la configuración del navegador.'
-            );
-        }
-    }
-
-    // ── Pedir ubicación ──────────────────────────────────
-    const defaultOptions: PositionOptions = {
-        enableHighAccuracy: options.enableHighAccuracy ?? true,
-        timeout: options.timeout ?? 10000,
-        maximumAge: options.maximumAge ?? 0,
-    };
-
-    return new Promise<GeoLocation>((resolve, reject) => {
-        navigator.geolocation.getCurrentPosition(
-            (position) => {
-                const { coords, timestamp } = position;
-                resolve({
-                    latitude: coords.latitude,
-                    longitude: coords.longitude,
-                    accuracy: coords.accuracy,
-                    altitude: coords.altitude,
-                    altitudeAccuracy: coords.altitudeAccuracy,
-                    heading: coords.heading,
-                    speed: coords.speed,
-                    timestamp,
-                });
-            },
-            (error) => {
-                switch (error.code) {
-                    case error.PERMISSION_DENIED:
-                        reject(new Error('Has denegado el permiso de ubicación.'));
-                        break;
-                    case error.POSITION_UNAVAILABLE:
-                        reject(new Error('No se pudo determinar tu ubicación.'));
-                        break;
-                    case error.TIMEOUT:
-                        reject(new Error('Tiempo de espera agotado al obtener la ubicación.'));
-                        break;
-                    default:
-                        reject(new Error('Error desconocido al obtener la ubicación.'));
-                }
-            },
-            defaultOptions,
-        );
-    });
+// ─── Tipos ───────────────────────────────────────────────
+
+export interface GeoLocation {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+    timestamp: number;
+}
+
+export interface GeoLocationOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+}
+
+// ─── Helpers ─────────────────────────────────────────────
+
+function positionToGeoLocation(position: GeolocationPosition): GeoLocation {
+    const {coords, timestamp} = position;
+    return {
+        latitude: coords.latitude,
+        longitude: coords.longitude,
+        accuracy: coords.accuracy,
+        altitude: coords.altitude,
+        altitudeAccuracy: coords.altitudeAccuracy,
+        heading: coords.heading,
+        speed: coords.speed,
+        timestamp,
+    };
+}
+
+function geolocationError(error: GeolocationPositionError): Error {
+    switch (error.code) {
+        case error.PERMISSION_DENIED:
+            return new Error('Has denegado el permiso de ubicación.');
+        case error.POSITION_UNAVAILABLE:
+            return new Error('No se pudo determinar tu ubicación.');
+        case error.TIMEOUT:
+            return new Error('Tiempo de espera agotado al obtener la ubicación.');
+        default:
+            return new Error('Error desconocido al obtener la ubicación.');
+    }
+}
+
+function requestPosition(options: PositionOptions): Promise<GeoLocation> {
+    return new Promise((resolve, reject) => {
+        navigator.geolocation.getCurrentPosition(
+            (position) => resolve(positionToGeoLocation(position)),
+            (error) => reject(geolocationError(error)),
+            options,
+        );
+    });
+}
+
+async function ensurePermission(): Promise<void> {
+    if (!navigator.permissions) return;
+
+    const permission = await navigator.permissions.query({name: 'geolocation'});
+
+    if (permission.state === 'denied') {
+        throw new Error(
+            'Permiso de ubicación denegado. Actívalo en la configuración del navegador.',
+        );
+    }
+
+    if (permission.state === 'prompt') {
+        await new Promise<void>((resolve, reject) => {
+            // Escuchar cambio de estado del permiso
+            permission.onchange = () => {
+                permission.onchange = null;
+                if (permission.state === 'granted') {
+                    resolve();
+                } else {
+                    reject(new Error('Has denegado el permiso de ubicación.'));
+                }
+            };
+
+            // Forzar el diálogo nativo del navegador
+            navigator.geolocation.getCurrentPosition(
+                () => {
+                    permission.onchange = null;
+                    resolve();
+                },
+                (error) => {
+                    permission.onchange = null;
+                    reject(geolocationError(error));
+                },
+                {timeout: 30000},
+            );
+        });
+    }
+}
+
+// ─── Función principal ──────────────────────────────────
+
+export default async function getGeoLocation(
+    options: GeoLocationOptions = {},
+): Promise<GeoLocation> {
+    if (!navigator.geolocation) {
+        throw new Error('Tu navegador no soporta geolocalización.');
+    }
+
+    await ensurePermission();
+
+    return requestPosition({
+        enableHighAccuracy: options.enableHighAccuracy ?? true,
+        timeout: options.timeout ?? 10000,
+        maximumAge: options.maximumAge ?? 0,
+    });
 }

package/src/browser/index.ts

@@ -1,5 +1,79 @@
-export * from './form-utilities.js'
-
-export {default as NativeBridge} from "./native-bridge.js"
-
+interface FetchIntoOptions {
+    url?: string;
+    fetchOptions?: RequestInit;
+    runScripts?: boolean;
+    transition?: string;
+}
+
+export async function fetchInto(
+    selector: string,
+    options: FetchIntoOptions = {}
+): Promise<number> {
+    const {
+        url = window.location.href,
+        fetchOptions = {},
+        runScripts = false,
+        transition = null,
+    } = options;
+
+    const response = await fetch(url, fetchOptions);
+
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const html = await response.text();
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    const oldElements = document.querySelectorAll(selector);
+    let replacedCount = 0;
+
+    for (let i = 0; i < oldElements.length; i++) {
+        const oldEl = oldElements[i];
+        const newEl = doc.querySelector(selector);
+
+        if (!newEl) continue;
+
+        if (transition) {
+            oldEl.classList.add(transition);
+            await new Promise<void>((r) =>
+                requestAnimationFrame(() => requestAnimationFrame(() => r()))
+            );
+        }
+
+        oldEl.replaceWith(newEl.cloneNode(true));
+
+        if (runScripts) {
+            const scripts = newEl.querySelectorAll("script");
+
+            for (let j = 0; j < scripts.length; j++) {
+                const script = scripts[j];
+                const fresh = document.createElement("script");
+
+                if (script.src) {
+                    fresh.src = script.src;
+                } else {
+                    fresh.textContent = script.textContent;
+                }
+
+                const attrs = script.attributes;
+                for (let k = 0; k < attrs.length; k++) {
+                    if (attrs[k].name !== "src") {
+                        fresh.setAttribute(attrs[k].name, attrs[k].value);
+                    }
+                }
+
+                script.replaceWith(fresh);
+            }
+        }
+
+        replacedCount++;
+    }
+
+    return replacedCount;
+}
+
+export * from './form-utilities.js'
+
+export {default as NativeBridge} from "./native-bridge.js"
+
 export {default as getGeoLocation} from './geo-location.js';

package/src/browser/native-bridge.ts

@@ -1,117 +1,117 @@
-// ─── Tipos ───────────────────────────────────────────────
-interface BridgeOptions {
-    channel: Channel;
-    timeout?: number | null;
-    callbackName?: string;        // ← nuevo
-}
-interface PendingCall {
-    resolve: (value: unknown) => void;
-    reject: (reason: Error) => void;
-    timer: ReturnType<typeof setTimeout> | null;
-}
-
-interface Channel {
-    postMessage: (message: string) => void;
-}
-
-
-
-// ─── Clase ──────────────────────────────────────────────
-
-export default class NativeBridge {
-    private _pending = new Map<number, PendingCall>();
-    private _callId = 0;
-    private readonly _defaultTimeout: number | null;
-    private readonly _channel: Channel;
-
-
-    constructor({ channel, timeout = 3000, callbackName = '__nativeResponseHandler' }: BridgeOptions) {
-        this._defaultTimeout = timeout;
-        this._channel = channel;
-
-        if (!this._channel) {
-            throw new Error('Channel not found');
-        }
-
-        (window as any)[callbackName] = this._callback;
-
-        // Proxy: cualquier propiedad no existente se convierte en call()
-        return new Proxy(this, {
-            get(target: NativeBridge, prop: string | symbol) {
-                if (prop in target) {
-                    return (target as any)[prop];
-                }
-                return (data?: unknown, timeout?: number | null) => target.call(String(prop), data, timeout);
-            },
-        }) as unknown as NativeBridge;
-    }
-
-
-    private _callback(id: number, error: any, result: any) {
-
-        const pending = this._pending.get(id);
-        if (!pending) {
-            return;
-        }
-
-        if (pending.timer !== null) {
-            clearTimeout(pending.timer);
-        }
-
-        this._pending.delete(id);
-
-        if (error) {
-            pending.reject(error instanceof Error? error : new Error(String(error)));
-        } else {
-            pending.resolve(result);
-        }
-    }
-
-    call(method: string, data: unknown = null, timeout?: number | null): Promise<unknown> {
-
-
-        const effectiveTimeout = timeout !== undefined ? timeout : this._defaultTimeout;
-
-        return new Promise<unknown>((resolve, reject) => {
-            const id = this._callId++;
-
-            let timer: ReturnType<typeof setTimeout> | null = null;
-
-            // Solo crear timer si hay timeout
-            if (effectiveTimeout !== null && effectiveTimeout > 0) {
-                timer = setTimeout(() => {
-                    this._pending.delete(id);
-                    reject(new Error(`Timeout (${effectiveTimeout}ms): ${method}`));
-                }, effectiveTimeout);
-            }
-
-            this._pending.set(id, { resolve, reject, timer });
-            this._channel!.postMessage(JSON.stringify({ id, method, data }));
-        });
-    }
-
-
-    send(method: string, data: unknown = null): void {
-        this._channel!.postMessage(JSON.stringify({ method, data }));
-    }
-
-    /**
-     * Número de llamadas pendientes
-     */
-    get pendingCount(): number {
-        return this._pending.size;
-    }
-
-    /**
-     * Cancela todas las llamadas pendientes
-     */
-    cancelAll(): void {
-        for (const [, { reject, timer }] of this._pending) {
-            if (timer !== null) {
-                clearTimeout(timer);
-            }
-            reject(new Error('Cancelled'));
-        }
-        this._pending.clear();
-    }
+// ─── Tipos ───────────────────────────────────────────────
+interface BridgeOptions {
+    channel: Channel;
+    timeout?: number | null;
+    callbackName?: string;        // ← nuevo
+}
+interface PendingCall {
+    resolve: (value: unknown) => void;
+    reject: (reason: Error) => void;
+    timer: ReturnType<typeof setTimeout> | null;
+}
+
+interface Channel {
+    postMessage: (message: string) => void;
+}
+
+
+
+// ─── Clase ──────────────────────────────────────────────
+
+export default class NativeBridge {
+    private _pending = new Map<number, PendingCall>();
+    private _callId = 0;
+    private readonly _defaultTimeout: number | null;
+    private readonly _channel: Channel;
+
+
+    constructor({ channel, timeout = 3000, callbackName = '__nativeResponseHandler' }: BridgeOptions) {
+        this._defaultTimeout = timeout;
+        this._channel = channel;
+
+        if (!this._channel) {
+            throw new Error('Channel not found');
+        }
+
+        (window as any)[callbackName] = this._callback;
+
+        // Proxy: cualquier propiedad no existente se convierte en call()
+        return new Proxy(this, {
+            get(target: NativeBridge, prop: string | symbol) {
+                if (prop in target) {
+                    return (target as any)[prop];
+                }
+                return (data?: unknown, timeout?: number | null) => target.call(String(prop), data, timeout);
+            },
+        }) as unknown as NativeBridge;
+    }
+
+
+    private _callback(id: number, error: any, result: any) {
+
+        const pending = this._pending.get(id);
+        if (!pending) {
+            return;
+        }
+
+        if (pending.timer !== null) {
+            clearTimeout(pending.timer);
+        }
+
+        this._pending.delete(id);
+
+        if (error) {
+            pending.reject(error instanceof Error? error : new Error(String(error)));
+        } else {
+            pending.resolve(result);
+        }
+    }
+
+    call(method: string, data: unknown = null, timeout?: number | null): Promise<unknown> {
+
+
+        const effectiveTimeout = timeout !== undefined ? timeout : this._defaultTimeout;
+
+        return new Promise<unknown>((resolve, reject) => {
+            const id = this._callId++;
+
+            let timer: ReturnType<typeof setTimeout> | null = null;
+
+            // Solo crear timer si hay timeout
+            if (effectiveTimeout !== null && effectiveTimeout > 0) {
+                timer = setTimeout(() => {
+                    this._pending.delete(id);
+                    reject(new Error(`Timeout (${effectiveTimeout}ms): ${method}`));
+                }, effectiveTimeout);
+            }
+
+            this._pending.set(id, { resolve, reject, timer });
+            this._channel!.postMessage(JSON.stringify({ id, method, data }));
+        });
+    }
+
+
+    send(method: string, data: unknown = null): void {
+        this._channel!.postMessage(JSON.stringify({ method, data }));
+    }
+
+    /**
+     * Número de llamadas pendientes
+     */
+    get pendingCount(): number {
+        return this._pending.size;
+    }
+
+    /**
+     * Cancela todas las llamadas pendientes
+     */
+    cancelAll(): void {
+        for (const [, { reject, timer }] of this._pending) {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+            reject(new Error('Cancelled'));
+        }
+        this._pending.clear();
+    }
 }

package/src/cancellable-promise.ts

@@ -1,77 +1,77 @@
-type CancellablePromiseExecutor<T> = (
-    resolve: (value: T | PromiseLike<T>) => void,
-    reject: (reason?: unknown) => void,
-    signal: AbortSignal
-) => void;
-
-export default class CancellablePromise<T> extends Promise<T> {
-
-    private _controller: AbortController;
-
-    static get [Symbol.species]() {
-        return Promise;
-    }
-
-    constructor(executor: CancellablePromiseExecutor<T>) {
-        const controller = new AbortController();
-
-        super((resolve, reject) => {
-            controller.signal.addEventListener("abort", () => {
-                reject(controller.signal.reason);
-            });
-
-            executor(resolve, reject, controller.signal);
-        });
-
-        this._controller = controller;
-    }
-
-    get cancelled(): boolean {
-        return this._controller.signal.aborted;
-    }
-
-    cancel(reason: unknown = new Error("Promesa cancelada")): void {
-        if (!this.cancelled) {
-            this._controller.abort(reason);
-        }
-    }
-
-    static async compete<T>(promises: CancellablePromise<T>[]): Promise<T> {
-        return await Promise.race(promises).then(
-            (resultado) => {
-                for (const p of promises) {
-                    p.cancel();
-                }
-                return resultado;
-            },
-            (error) => {
-                for (const p of promises) {
-                    p.cancel();
-                }
-                throw error;
-            }
-        );
-    }
-
-    static async cooperate<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
-        try {
-            return await Promise.all(promises);
-        } catch (error) {
-            for (const p of promises) {
-                p.cancel();
-            }
-            throw error;
-        }
-    }
-
-    static withTimeout<T>(executor: CancellablePromiseExecutor<T>, ms: number): CancellablePromise<T> {
-        return new CancellablePromise<T>((resolve, reject, signal) => {
-            const timer = setTimeout(() => {
-                reject(new Error(`Timeout: ${ms}ms`));
-            }, ms);
-
-            signal.addEventListener("abort", () => clearTimeout(timer));
-            executor(resolve, reject, signal);
-        });
-    }
+type CancellablePromiseExecutor<T> = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: unknown) => void,
+    signal: AbortSignal
+) => void;
+
+export default class CancellablePromise<T> extends Promise<T> {
+
+    private _controller: AbortController;
+
+    static get [Symbol.species]() {
+        return Promise;
+    }
+
+    constructor(executor: CancellablePromiseExecutor<T>) {
+        const controller = new AbortController();
+
+        super((resolve, reject) => {
+            controller.signal.addEventListener("abort", () => {
+                reject(controller.signal.reason);
+            });
+
+            executor(resolve, reject, controller.signal);
+        });
+
+        this._controller = controller;
+    }
+
+    get cancelled(): boolean {
+        return this._controller.signal.aborted;
+    }
+
+    cancel(reason: unknown = new Error("Promesa cancelada")): void {
+        if (!this.cancelled) {
+            this._controller.abort(reason);
+        }
+    }
+
+    static async compete<T>(promises: CancellablePromise<T>[]): Promise<T> {
+        return await Promise.race(promises).then(
+            (resultado) => {
+                for (const p of promises) {
+                    p.cancel();
+                }
+                return resultado;
+            },
+            (error) => {
+                for (const p of promises) {
+                    p.cancel();
+                }
+                throw error;
+            }
+        );
+    }
+
+    static async cooperate<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
+        try {
+            return await Promise.all(promises);
+        } catch (error) {
+            for (const p of promises) {
+                p.cancel();
+            }
+            throw error;
+        }
+    }
+
+    static withTimeout<T>(executor: CancellablePromiseExecutor<T>, ms: number): CancellablePromise<T> {
+        return new CancellablePromise<T>((resolve, reject, signal) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Timeout: ${ms}ms`));
+            }, ms);
+
+            signal.addEventListener("abort", () => clearTimeout(timer));
+            executor(resolve, reject, signal);
+        });
+    }
 }