@develia/commons 0.4.9 → 0.4.13

package/src/browser/form-utilities.ts

@@ -1,174 +1,180 @@
-import {type Optional, type Supplier} from "../types.js";
-
-
-/**
- * Submits a form via AJAX and returns a Promise that resolves to the Response object.
- *
- * @param {HTMLFormElement | string} selectorOrElement - The form element or selector.
- * @return {Promise<Response>} A Promise that resolves to the Response object.
- * @throws {Error} If the element is invalid.
- */
-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 submitForm(
-    url: string,
-    data: Record<string, any>,
-    method: 'POST' | 'GET' = 'POST',
-    target?: '_blank' | '_self' | '_parent' | '_top'
-): void {
-
-    const form = document.createElement('form');
-    form.method = method.toUpperCase();
-    form.action = url;
-    form.style.display = 'none';
-
-    if (target) {
-        form.target = target;
-    }
-
-    /**
-     * Recursively appends inputs to the form, supporting nested keys and arrays.
-     * @param keyPrefix - Key path, e.g., 'user[name]' or 'tags[]'
-     * @param value - The value to append (can be nested)
-     */
-    const appendInputs = (keyPrefix: string, value: any) => {
-        if (Array.isArray(value)) {
-            value.forEach(val => {
-                appendInputs(`${keyPrefix}[]`, val);
-            });
-        } else if (typeof value === 'object' && value !== null) {
-            for (const subKey in value) {
-                if (value.hasOwnProperty(subKey)) {
-                    appendInputs(`${keyPrefix}[${subKey}]`, value[subKey]);
-                }
-            }
-        } else {
-            const input = document.createElement('input');
-            input.type = 'hidden';
-            input.name = keyPrefix;
-            input.value = String(value);
-            form.appendChild(input);
-        }
-    };
-
-    for (const key in data) {
-        if (data.hasOwnProperty(key)) {
-            appendInputs(key, data[key]);
-        }
-    }
-
-    document.body.appendChild(form);
-    form.submit();
-}
-
-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;
-        }
-    }
-
-    return out;
-}
-
-/**
- * Converts an object to `FormData` format recursively.
- *
- * @param {Record<string, any>} data - The object data to convert.
- * @param {FormData} formData - The `FormData` instance to append data to.
- * @param {string} parentKey - The parent key to append to child keys in the `FormData`.
- * @returns {FormData} - The `FormData` instance with the converted data.
- */
-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;
-}
-
-/**
- * Converts an object into FormData.
- *
- * @param {Record<string, any>} data - The object to be converted into FormData.
- * @return {FormData} - The FormData object representing the converted data.
- */
-export function objectToFormData(data: Record<string, any>): FormData {
-    let formData = new FormData();
-    return _objectToFormData(data, formData);
-}
-
-export function ajaxSubmission(selectorOrElement: HTMLFormElement | string,
-                               onSuccess: Optional<Supplier<any>> = undefined,
-                               onFailure: Optional<Supplier<any>> = undefined): void {
-
-    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);
-        }
-
-    });
-
-
+import {type Consumer, type Optional} from "../types.js";
+
+
+/**
+ * Submits a form via AJAX and returns a Promise that resolves to the Response object.
+ *
+ * @param {HTMLFormElement | string} selectorOrElement - The form element or selector.
+ * @return {Promise<Response>} A Promise that resolves to the Response object.
+ * @throws {Error} If the element is invalid.
+ */
+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.");
+    }
+
+
+    const formData = new FormData(form);
+    const method = form.getAttribute('method') as string ?? form.method;
+    const action = form.getAttribute('action') as string ?? form.action;
+
+    return await fetch(action, {
+        method: method,
+        body: formData,
+    });
+}
+
+
+export function submitForm(
+    url: string,
+    data: Record<string, any>,
+    method: 'POST' | 'GET' = 'POST',
+    target?: '_blank' | '_self' | '_parent' | '_top'
+): void {
+
+    const form = document.createElement('form');
+    form.method = method.toUpperCase();
+    form.action = url;
+    form.style.display = 'none';
+
+    if (target) {
+        form.target = target;
+    }
+
+    /**
+     * Recursively appends inputs to the form, supporting nested keys and arrays.
+     * @param keyPrefix - Key path, e.g., 'user[name]' or 'tags[]'
+     * @param value - The value to append (can be nested)
+     */
+    const appendInputs = (keyPrefix: string, value: any) => {
+        if (Array.isArray(value)) {
+            value.forEach(val => {
+                appendInputs(`${keyPrefix}[]`, val);
+            });
+        } else if (typeof value === 'object' && value !== null) {
+            for (const subKey in value) {
+                if (value.hasOwnProperty(subKey)) {
+                    appendInputs(`${keyPrefix}[${subKey}]`, value[subKey]);
+                }
+            }
+        } else {
+            const input = document.createElement('input');
+            input.type = 'hidden';
+            input.name = keyPrefix;
+            input.value = String(value);
+            form.appendChild(input);
+        }
+    };
+
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            appendInputs(key, data[key]);
+        }
+    }
+
+    document.body.appendChild(form);
+    form.submit();
+}
+
+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;
+        }
+    }
+
+    return out;
+}
+
+/**
+ * Converts an object to `FormData` format recursively.
+ *
+ * @param {Record<string, any>} data - The object data to convert.
+ * @param {FormData} formData - The `FormData` instance to append data to.
+ * @param {string} parentKey - The parent key to append to child keys in the `FormData`.
+ * @returns {FormData} - The `FormData` instance with the converted data.
+ */
+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;
+}
+
+/**
+ * Converts an object into FormData.
+ *
+ * @param {Record<string, any>} data - The object to be converted into FormData.
+ * @return {FormData} - The FormData object representing the converted data.
+ */
+export function objectToFormData(data: Record<string, any>): FormData {
+    let formData = new FormData();
+    return _objectToFormData(data, formData);
+}
+
+export function ajaxSubmission(
+    selectorOrElement: HTMLFormElement | string,
+    onSuccess: Optional<Consumer<any>> = undefined,
+    onFailure: Optional<Consumer<any>> = undefined
+): void {
+
+    const forms: HTMLFormElement[] = typeof selectorOrElement === 'string'
+            ? Array.from(document.querySelectorAll(selectorOrElement))
+                   .filter(el => el instanceof HTMLFormElement) as HTMLFormElement[]
+            : [selectorOrElement];
+
+    forms.forEach(form => {
+        form.addEventListener('submit', async (event) => {
+            event.preventDefault();
+
+            try {
+                let result = await ajaxSubmit(event.currentTarget as HTMLFormElement);
+                if (onSuccess)
+                    onSuccess(result);
+            } catch (e) {
+                if (onFailure)
+                    onFailure(e);
+            }
+
+
+        });
+    });
 }

package/src/browser/geo-location.ts

@@ -3,78 +3,112 @@
 export interface GeoLocation {
     latitude: number;
     longitude: number;
-    accuracy: number;          // metros
+    accuracy: number;
     altitude: number | null;
     altitudeAccuracy: number | null;
-    heading: number | null;    // grados desde el norte
-    speed: number | null;      // m/s
+    heading: number | null;
+    speed: number | null;
     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
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
 }
 
-// ─── Función ─────────────────────────────────────────────
+// ─── Helpers ─────────────────────────────────────────────
 
-export default async function getGeoLocation(options: GeoLocationOptions = {}): Promise<GeoLocation> {
+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,
+    };
+}
 
-    // ── Soporte del navegador ────────────────────────────
-    if (!navigator.geolocation) {
-        throw new Error('Tu navegador no soporta geolocalización.');
+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.',
+        );
     }
 
-    // ── Comprobar permisos (API Permissions) ─────────────
-    if (navigator.permissions) {
-        const permission = await navigator.permissions.query({ name: 'geolocation' });
+    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.'));
+                }
+            };
 
-        if (permission.state === 'denied') {
-            throw new Error(
-                'Permiso de ubicación denegado. Actívalo en la configuración del navegador.'
+            // 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.');
     }
 
-    // ── Pedir ubicación ──────────────────────────────────
-    const defaultOptions: PositionOptions = {
+    await ensurePermission();
+
+    return requestPosition({
         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,
-        );
     });
 }

package/src/browser/index.ts

@@ -1,5 +1,116 @@
-export * from './form-utilities.js'
-
-export {default as NativeBridge} from "./native-bridge.js"
-
+import {delay} from "../utilities.js";
+
+interface FetchIntoOptions {
+    url?: string;
+    fetchOptions?: RequestInit;
+    runScripts?: boolean;
+    transition?: string;
+}
+
+export async function waitFor(
+    selector: string,
+    options: { timeout?: number } = {}
+): Promise<HTMLElement | null> {
+    const {timeout = 5000} = options;
+
+    const element = document.querySelector(selector);
+    if (element) {
+        return element as HTMLElement;
+    }
+
+    let observer: MutationObserver | undefined;
+    const timeoutPromise = delay(timeout).then(() => {
+        observer?.disconnect();
+        return null;
+    });
+
+    const observerPromise = new Promise<HTMLElement | null>((resolve) => {
+        observer = new MutationObserver(() => {
+            const element = document.querySelector(selector);
+            if (element) {
+                observer?.disconnect();
+                resolve(element as HTMLElement);
+            }
+        });
+
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+    });
+
+    return Promise.race([observerPromise, timeoutPromise]);
+}
+
+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';