@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/navigation.js

@@ -0,0 +1,30 @@
+const REDIRECT_PARAM = "redirect";
+function safeInternalPath(candidatePath) {
+  if (typeof candidatePath !== "string" || candidatePath.length === 0 || candidatePath.length > 2e3) {
+    return null;
+  }
+  if (!candidatePath.startsWith("/") || candidatePath.startsWith("//") || candidatePath.startsWith("/\\")) {
+    return null;
+  }
+  if (/[\u0000-\u001f\u007f]/.test(candidatePath)) {
+    return null;
+  }
+  return candidatePath;
+}
+function readRedirectParam(search) {
+  return safeInternalPath(new URLSearchParams(search).get(REDIRECT_PARAM));
+}
+function withRedirect(entryPath, targetPath) {
+  const safeTarget = safeInternalPath(targetPath);
+  if (!safeTarget || safeTarget === "/" || safeTarget.startsWith(entryPath)) {
+    return entryPath;
+  }
+  return `${entryPath}?${new URLSearchParams({ [REDIRECT_PARAM]: safeTarget })}`;
+}
+export {
+  REDIRECT_PARAM,
+  readRedirectParam,
+  safeInternalPath,
+  withRedirect
+};
+//# sourceMappingURL=navigation.js.map

package/dist/navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.js","sources":["../src/navigation.js"],"sourcesContent":["// A dónde regresar después de iniciar sesión.\n//\n// Si la sesión vence a media consulta, la persona vuelve a /iniciar-sesion?redirect=/pedidos?estado=pendiente\n// y, al entrar, aterriza donde estaba.\n//\n// IMPORTANTE: el destino viene de la URL, así que cualquiera puede armar un enlace con él. Solo se aceptan rutas\n// internas (\"/algo\"); \"https://otro.sitio\", \"//otro.sitio\" o \"/\\otro.sitio\" se descartan. Sin esto, el login\n// sería un redirector abierto para phishing.\n//\n// Funciones puras, no renderizan: function (regla de la casa).\n\nexport const REDIRECT_PARAM = 'redirect';\n\n/**\n * La ruta si es interna y segura; null si no.\n *\n * @param {string|null|undefined} candidatePath\n * @returns {string|null}\n */\nexport function safeInternalPath(candidatePath) {\n    if (typeof candidatePath !== 'string' || candidatePath.length === 0 || candidatePath.length > 2000) {\n        return null;\n    }\n    // guard clause: tiene que empezar con una sola diagonal (// y /\\ son URLs de otro dominio para el navegador)\n    if (!candidatePath.startsWith('/') || candidatePath.startsWith('//') || candidatePath.startsWith('/\\\\')) {\n        return null;\n    }\n    // guard clause: sin caracteres de control (un salto de línea puede partir la URL)\n    if (/[\\u0000-\\u001f\\u007f]/.test(candidatePath)) {\n        return null;\n    }\n    return candidatePath;\n}\n\n/**\n * Lee el destino de ?redirect= ya validado.\n *\n * @param {string} search location.search\n * @returns {string|null}\n */\nexport function readRedirectParam(search) {\n    return safeInternalPath(new URLSearchParams(search).get(REDIRECT_PARAM));\n}\n\n/**\n * Arma \"/iniciar-sesion?redirect=<destino>\" (sin parámetro si el destino no es seguro o es la misma entrada).\n *\n * @param {string} entryPath p. ej. '/iniciar-sesion'\n * @param {string} targetPath ruta que se intentó abrir\n */\nexport function withRedirect(entryPath, targetPath) {\n    const safeTarget = safeInternalPath(targetPath);\n    if (!safeTarget || safeTarget === '/' || safeTarget.startsWith(entryPath)) {\n        return entryPath;\n    }\n    return `${entryPath}?${new URLSearchParams({[REDIRECT_PARAM]: safeTarget})}`;\n}\n"],"names":[],"mappings":"AAWY,MAAC,iBAAiB;AAQvB,SAAS,iBAAiB,eAAe;AAC5C,MAAI,OAAO,kBAAkB,YAAY,cAAc,WAAW,KAAK,cAAc,SAAS,KAAM;AAChG,WAAO;AAAA,EACX;AAEA,MAAI,CAAC,cAAc,WAAW,GAAG,KAAK,cAAc,WAAW,IAAI,KAAK,cAAc,WAAW,KAAK,GAAG;AACrG,WAAO;AAAA,EACX;AAEA,MAAI,wBAAwB,KAAK,aAAa,GAAG;AAC7C,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAQO,SAAS,kBAAkB,QAAQ;AACtC,SAAO,iBAAiB,IAAI,gBAAgB,MAAM,EAAE,IAAI,cAAc,CAAC;AAC3E;AAQO,SAAS,aAAa,WAAW,YAAY;AAChD,QAAM,aAAa,iBAAiB,UAAU;AAC9C,MAAI,CAAC,cAAc,eAAe,OAAO,WAAW,WAAW,SAAS,GAAG;AACvE,WAAO;AAAA,EACX;AACA,SAAO,GAAG,SAAS,IAAI,IAAI,gBAAgB,EAAC,CAAC,cAAc,GAAG,WAAU,CAAC,CAAC;AAC9E;"}

package/dist/navigationTrail.js

@@ -0,0 +1,82 @@
+"use client";
+import { useRef, useLayoutEffect, useEffect } from "react";
+import { useToolkitNavigation } from "./toolkit/toolkitContext.js";
+const STORAGE_KEY = "calcita:navigationTrail";
+function tabStorage() {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+function currentHistoryIndex() {
+  if (typeof window === "undefined") {
+    return 0;
+  }
+  return window.history.state?.idx ?? 0;
+}
+function readTrail(storage) {
+  try {
+    const storedTrail = storage?.getItem(STORAGE_KEY);
+    const trail = storedTrail ? JSON.parse(storedTrail) : {};
+    return trail !== null && typeof trail === "object" && !Array.isArray(trail) ? trail : {};
+  } catch {
+    return {};
+  }
+}
+function writeTrail(storage, trail) {
+  try {
+    storage?.setItem(STORAGE_KEY, JSON.stringify(trail));
+  } catch {
+  }
+}
+function trailUpTo(trail, index) {
+  return Object.fromEntries(Object.entries(trail).filter(([position]) => Number(position) <= index));
+}
+function rememberPageName(index, pageName, storage = tabStorage()) {
+  const trail = trailUpTo(readTrail(storage), index);
+  trail[index] = { labelKey: pageName.labelKey, params: pageName.params ?? {} };
+  writeTrail(storage, trail);
+}
+function forgetPageName(index, storage = tabStorage()) {
+  const trail = trailUpTo(readTrail(storage), index);
+  delete trail[index];
+  writeTrail(storage, trail);
+}
+function pageNameAt(index, storage = tabStorage()) {
+  const pageName = readTrail(storage)[index];
+  return pageName && typeof pageName.labelKey === "string" ? pageName : null;
+}
+function useNavigationTrail() {
+  const { useLocation } = useToolkitNavigation();
+  const { pathname } = useLocation();
+  const shownPage = useRef(null);
+  useLayoutEffect(() => {
+    const index = currentHistoryIndex();
+    if (shownPage.current?.index === index && shownPage.current?.pathname === pathname) {
+      return;
+    }
+    forgetPageName(index);
+    shownPage.current = { index, pathname };
+  });
+}
+function usePageName(labelKey, params) {
+  const { useLocation } = useToolkitNavigation();
+  const { key } = useLocation();
+  const paramsText = JSON.stringify(params ?? {});
+  useEffect(() => {
+    if (!labelKey) {
+      return;
+    }
+    rememberPageName(currentHistoryIndex(), { labelKey, params: JSON.parse(paramsText) });
+  }, [labelKey, paramsText, key]);
+}
+export {
+  currentHistoryIndex,
+  forgetPageName,
+  pageNameAt,
+  rememberPageName,
+  useNavigationTrail,
+  usePageName
+};
+//# sourceMappingURL=navigationTrail.js.map

package/dist/navigationTrail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationTrail.js","sources":["../src/navigationTrail.js"],"sourcesContent":["// Cómo se llama cada página para el botón «Regresar» de la página que sigue.\n//\n// Sin esto, el botón dice un texto fijo («Regresar a la lista») aunque regrese a otra página. BackButton regresa con\n// navigate(-1), a la entrada anterior del historial de esta pestaña; para que su TEXTO diga a dónde va, cada página\n// anota aquí su nombre de regreso («Regresar al detalle del pedido 15») junto a su posición en el historial\n// (history.state.idx que pone react-router), y BackButton lee el de la posición anterior. Sin historial (enlace pegado, pestaña nueva, recarga después\n// de iniciar sesión) no hay nada que leer y BackButton usa el texto de siempre.\n//\n// OJO: una posición se reusa. Si el usuario regresa y entra a otra página, la nueva ocupa la misma posición. Por eso\n// useNavigationTrail (montado una sola vez en el layout de la aplicación) borra el nombre de la posición en cuanto cambia la página, ANTES de\n// que la página nueva anote el suyo: el borrado va en un efecto de layout y la anotación en un efecto normal, y React\n// corre todos los de layout antes que los normales. Una página que no anota su nombre deja su posición vacía, y el\n// BackButton de la siguiente usa el texto que le pasen.\n//\n// Se guarda la llave del texto con sus valores y no el texto: así un cambio de idioma lo traduce. sessionStorage por lo\n// mismo que lastListUrl.js: es de esta pestaña y se borra al cerrarla.\n//\n// Funciones puras y hooks, no renderizan: function (regla de la casa).\nimport {useEffect, useLayoutEffect, useRef} from 'react';\nimport {useToolkitNavigation} from '@/toolkit/toolkitContext.js';\n\nconst STORAGE_KEY = 'calcita:navigationTrail';\n\n/**\n * El almacenamiento de esta pestaña; null si el navegador lo bloquea o si no hay ventana (pruebas).\n *\n * @returns {Storage|null}\n */\nfunction tabStorage() {\n    try {\n        return typeof window === 'undefined' ? null : (window.sessionStorage ?? null);\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Posición de la página actual en el historial de esta pestaña: 0 es la primera página de la app.\n *\n * @returns {number}\n */\nexport function currentHistoryIndex() {\n    if (typeof window === 'undefined') {\n        return 0;\n    }\n    return window.history.state?.idx ?? 0;\n}\n\n/**\n * El camino guardado; uno roto o ilegible cuenta como vacío (el botón vuelve a su texto de siempre).\n *\n * @param {Storage|null} storage\n * @returns {Record<string, {labelKey: string, params: object}>}\n */\nfunction readTrail(storage) {\n    try {\n        const storedTrail = storage?.getItem(STORAGE_KEY);\n        const trail = storedTrail ? JSON.parse(storedTrail) : {};\n        return trail !== null && typeof trail === 'object' && !Array.isArray(trail) ? trail : {};\n    } catch {\n        return {};\n    }\n}\n\n/**\n * @param {Storage|null} storage\n * @param {Record<string, {labelKey: string, params: object}>} trail\n */\nfunction writeTrail(storage, trail) {\n    try {\n        storage?.setItem(STORAGE_KEY, JSON.stringify(trail));\n    } catch {\n        // almacenamiento lleno o bloqueado: el botón vuelve a su texto de siempre\n    }\n}\n\n/**\n * El camino sin las posiciones posteriores a la que se toca: al entrar a una página en esa posición, el navegador ya\n * descartó las que seguían (y si el usuario avanza con el botón del navegador, esas páginas vuelven a anotar su nombre).\n *\n * @param {Record<string, {labelKey: string, params: object}>} trail\n * @param {number} index\n * @returns {Record<string, {labelKey: string, params: object}>}\n */\nfunction trailUpTo(trail, index) {\n    return Object.fromEntries(Object.entries(trail).filter(([position]) => Number(position) <= index));\n}\n\n/**\n * Anota el nombre de regreso de la página que está en esa posición del historial.\n *\n * @param {number} index posición en el historial (currentHistoryIndex)\n * @param {{labelKey: string, params?: object}} pageName llave de i18n con su espacio, p. ej. 'upload-control:detail.backToList'\n * @param {Storage|null} [storage] el de la pestaña; las pruebas pasan uno de mentiras\n */\nexport function rememberPageName(index, pageName, storage = tabStorage()) {\n    const trail = trailUpTo(readTrail(storage), index);\n    trail[index] = {labelKey: pageName.labelKey, params: pageName.params ?? {}};\n    writeTrail(storage, trail);\n}\n\n/**\n * Borra el nombre de esa posición (y los de las posteriores): una página nueva la ocupa.\n *\n * @param {number} index\n * @param {Storage|null} [storage]\n */\nexport function forgetPageName(index, storage = tabStorage()) {\n    const trail = trailUpTo(readTrail(storage), index);\n    delete trail[index];\n    writeTrail(storage, trail);\n}\n\n/**\n * El nombre de regreso anotado en esa posición; null si la página no anotó ninguno.\n *\n * @param {number} index\n * @param {Storage|null} [storage]\n * @returns {{labelKey: string, params: object}|null}\n */\nexport function pageNameAt(index, storage = tabStorage()) {\n    const pageName = readTrail(storage)[index];\n    return pageName && typeof pageName.labelKey === 'string' ? pageName : null;\n}\n\n/**\n * Se monta UNA vez en el layout de la aplicación: cuando cambia la página (otra posición u otra ruta), borra el nombre que tenía esa posición\n * antes de que la página nueva anote el suyo. Cambiar solo los parámetros de la URL en la misma posición (una pestaña,\n * un filtro) no cuenta como otra página.\n */\nexport function useNavigationTrail() {\n    const {useLocation} = useToolkitNavigation();\n    const {pathname} = useLocation();\n    const shownPage = useRef(null);\n\n    useLayoutEffect(() => {\n        const index = currentHistoryIndex();\n        if (shownPage.current?.index === index && shownPage.current?.pathname === pathname) {\n            return;\n        }\n        forgetPageName(index);\n        shownPage.current = {index, pathname};\n    });\n}\n\n/**\n * Se monta en una página: anota cómo se llama para el botón «Regresar» de la página que sigue. Mientras sus datos no\n * llegan (labelKey null) no anota nada.\n *\n * @param {string|null} labelKey llave de i18n con su espacio, p. ej. 'upload-control:detail.backToList'\n * @param {object} [params] valores de la llave, ya listos para pintarse\n */\nexport function usePageName(labelKey, params) {\n    const {useLocation} = useToolkitNavigation();\n    const {key} = useLocation();\n    const paramsText = JSON.stringify(params ?? {});\n\n    useEffect(() => {\n        if (!labelKey) {\n            return;\n        }\n        rememberPageName(currentHistoryIndex(), {labelKey, params: JSON.parse(paramsText)});\n    }, [labelKey, paramsText, key]);\n}\n"],"names":[],"mappings":";;;AAqBA,MAAM,cAAc;AAOpB,SAAS,aAAa;AAClB,MAAI;AACA,WAAO,OAAO,WAAW,cAAc,OAAQ,OAAO,kBAAkB;AAAA,EAC5E,QAAQ;AACJ,WAAO;AAAA,EACX;AACJ;AAOO,SAAS,sBAAsB;AAClC,MAAI,OAAO,WAAW,aAAa;AAC/B,WAAO;AAAA,EACX;AACA,SAAO,OAAO,QAAQ,OAAO,OAAO;AACxC;AAQA,SAAS,UAAU,SAAS;AACxB,MAAI;AACA,UAAM,cAAc,SAAS,QAAQ,WAAW;AAChD,UAAM,QAAQ,cAAc,KAAK,MAAM,WAAW,IAAI,CAAA;AACtD,WAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAA;AAAA,EAC1F,QAAQ;AACJ,WAAO,CAAA;AAAA,EACX;AACJ;AAMA,SAAS,WAAW,SAAS,OAAO;AAChC,MAAI;AACA,aAAS,QAAQ,aAAa,KAAK,UAAU,KAAK,CAAC;AAAA,EACvD,QAAQ;AAAA,EAER;AACJ;AAUA,SAAS,UAAU,OAAO,OAAO;AAC7B,SAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,MAAM,OAAO,QAAQ,KAAK,KAAK,CAAC;AACrG;AASO,SAAS,iBAAiB,OAAO,UAAU,UAAU,WAAU,GAAI;AACtE,QAAM,QAAQ,UAAU,UAAU,OAAO,GAAG,KAAK;AACjD,QAAM,KAAK,IAAI,EAAC,UAAU,SAAS,UAAU,QAAQ,SAAS,UAAU,GAAE;AAC1E,aAAW,SAAS,KAAK;AAC7B;AAQO,SAAS,eAAe,OAAO,UAAU,cAAc;AAC1D,QAAM,QAAQ,UAAU,UAAU,OAAO,GAAG,KAAK;AACjD,SAAO,MAAM,KAAK;AAClB,aAAW,SAAS,KAAK;AAC7B;AASO,SAAS,WAAW,OAAO,UAAU,cAAc;AACtD,QAAM,WAAW,UAAU,OAAO,EAAE,KAAK;AACzC,SAAO,YAAY,OAAO,SAAS,aAAa,WAAW,WAAW;AAC1E;AAOO,SAAS,qBAAqB;AACjC,QAAM,EAAC,YAAW,IAAI,qBAAoB;AAC1C,QAAM,EAAC,SAAQ,IAAI,YAAW;AAC9B,QAAM,YAAY,OAAO,IAAI;AAE7B,kBAAgB,MAAM;AAClB,UAAM,QAAQ,oBAAmB;AACjC,QAAI,UAAU,SAAS,UAAU,SAAS,UAAU,SAAS,aAAa,UAAU;AAChF;AAAA,IACJ;AACA,mBAAe,KAAK;AACpB,cAAU,UAAU,EAAC,OAAO,SAAQ;AAAA,EACxC,CAAC;AACL;AASO,SAAS,YAAY,UAAU,QAAQ;AAC1C,QAAM,EAAC,YAAW,IAAI,qBAAoB;AAC1C,QAAM,EAAC,IAAG,IAAI,YAAW;AACzB,QAAM,aAAa,KAAK,UAAU,UAAU,CAAA,CAAE;AAE9C,YAAU,MAAM;AACZ,QAAI,CAAC,UAAU;AACX;AAAA,IACJ;AACA,qBAAiB,oBAAmB,GAAI,EAAC,UAAU,QAAQ,KAAK,MAAM,UAAU,EAAC,CAAC;AAAA,EACtF,GAAG,CAAC,UAAU,YAAY,GAAG,CAAC;AAClC;"}

package/dist/next.js

@@ -0,0 +1,5 @@
+import { nextNavigation } from "./adapters/nextNavigation.js";
+export {
+  nextNavigation
+};
+//# sourceMappingURL=next.js.map

package/dist/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/observability/buildWatch.js

@@ -0,0 +1,19 @@
+import { isAnotherBuild } from "./publishedBuild.js";
+const BUILD_WATCH_ACTION = Object.freeze({ none: "none", notice: "notice", reload: "reload" });
+function buildWatchActionOf({ runningBuildId, publishedBuildId, hiddenMilliseconds = 0, reloadAfterHiddenMilliseconds = null }) {
+  if (!isAnotherBuild(runningBuildId, publishedBuildId)) {
+    return BUILD_WATCH_ACTION.none;
+  }
+  const wasAwayLongEnough = reloadAfterHiddenMilliseconds !== null && hiddenMilliseconds >= reloadAfterHiddenMilliseconds;
+  return wasAwayLongEnough ? BUILD_WATCH_ACTION.reload : BUILD_WATCH_ACTION.notice;
+}
+function publishedBuildIdOf(versionFile) {
+  const buildId = versionFile && typeof versionFile === "object" ? versionFile.buildId : null;
+  return typeof buildId === "string" && buildId !== "" ? buildId : null;
+}
+export {
+  BUILD_WATCH_ACTION,
+  buildWatchActionOf,
+  publishedBuildIdOf
+};
+//# sourceMappingURL=buildWatch.js.map

package/dist/observability/buildWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildWatch.js","sources":["../../src/observability/buildWatch.js"],"sourcesContent":["// Qué hacer cuando la app revisa qué versión del front está publicada (usePublishedBuildWatch):\n//   - la misma que corre: nada;\n//   - otra, y la app estuvo en segundo plano un buen rato (la abrió de nuevo desde el inicio del teléfono): recargar sola,\n//     como una app nativa que se actualizó mientras no se usaba;\n//   - otra, pero la persona solo salió un momento (a copiar un código del SMS) o la está usando: el aviso «Hay una versión\n//     nueva · Actualizar» (NewBuildNotice). Recargar ahí le borraría lo que llevaba escrito.\n//\n// Puras, sin React ni el navegador: se prueban solas.\nimport {isAnotherBuild} from '@/observability/publishedBuild.js';\n\n/** Lo que toca hacer al ver la versión publicada. */\nexport const BUILD_WATCH_ACTION = Object.freeze({none: 'none', notice: 'notice', reload: 'reload'});\n\n/**\n * @param {object} watch\n * @param {string|null|undefined} watch.runningBuildId la versión de esta pestaña (buildId de ToolkitProvider)\n * @param {string|null|undefined} watch.publishedBuildId la que está publicada\n * @param {number} [watch.hiddenMilliseconds] cuánto estuvo la app en segundo plano antes de esta revisión (0: no estuvo)\n * @param {number|null} [watch.reloadAfterHiddenMilliseconds] desde cuánto tiempo fuera se recarga sola; null: nunca\n *     (solo el aviso)\n * @returns {string} un valor de BUILD_WATCH_ACTION\n */\nexport function buildWatchActionOf({runningBuildId, publishedBuildId, hiddenMilliseconds = 0, reloadAfterHiddenMilliseconds = null}) {\n    if (!isAnotherBuild(runningBuildId, publishedBuildId)) {\n        return BUILD_WATCH_ACTION.none;\n    }\n    const wasAwayLongEnough = reloadAfterHiddenMilliseconds !== null && hiddenMilliseconds >= reloadAfterHiddenMilliseconds;\n    return wasAwayLongEnough ? BUILD_WATCH_ACTION.reload : BUILD_WATCH_ACTION.notice;\n}\n\n/**\n * La versión publicada que viene en el archivo de versión ({\"buildId\": \"…\"}); null si el archivo no la trae.\n *\n * @param {unknown} versionFile lo que se leyó del archivo (JSON ya convertido)\n * @returns {string|null}\n */\nexport function publishedBuildIdOf(versionFile) {\n    const buildId = versionFile && typeof versionFile === 'object' ? versionFile.buildId : null;\n    return typeof buildId === 'string' && buildId !== '' ? buildId : null;\n}\n"],"names":[],"mappings":";AAWY,MAAC,qBAAqB,OAAO,OAAO,EAAC,MAAM,QAAQ,QAAQ,UAAU,QAAQ,SAAQ,CAAC;AAW3F,SAAS,mBAAmB,EAAC,gBAAgB,kBAAkB,qBAAqB,GAAG,gCAAgC,KAAI,GAAG;AACjI,MAAI,CAAC,eAAe,gBAAgB,gBAAgB,GAAG;AACnD,WAAO,mBAAmB;AAAA,EAC9B;AACA,QAAM,oBAAoB,kCAAkC,QAAQ,sBAAsB;AAC1F,SAAO,oBAAoB,mBAAmB,SAAS,mBAAmB;AAC9E;AAQO,SAAS,mBAAmB,aAAa;AAC5C,QAAM,UAAU,eAAe,OAAO,gBAAgB,WAAW,YAAY,UAAU;AACvF,SAAO,OAAO,YAAY,YAAY,YAAY,KAAK,UAAU;AACrE;"}

package/dist/observability/logger.js

@@ -0,0 +1,43 @@
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+const LOG_LEVEL_STORAGE_KEY = "calcita:logLevel";
+let defaultLevel = LEVELS.warn;
+function setLogLevel(level) {
+  if (!(level in LEVELS)) {
+    throw new Error(`setLogLevel espera error, warn, info o debug y recibió «${level}»`);
+  }
+  defaultLevel = LEVELS[level];
+}
+function currentLevel() {
+  try {
+    const override = window.localStorage?.getItem(LOG_LEVEL_STORAGE_KEY);
+    if (override && override in LEVELS) {
+      return LEVELS[override];
+    }
+  } catch {
+  }
+  return defaultLevel;
+}
+function emit(level, namespace, message, context) {
+  if (LEVELS[level] > currentLevel()) {
+    return;
+  }
+  const write = level === "debug" ? console.log : console[level] ?? console.log;
+  if (context === void 0) {
+    write(`[${namespace}] ${message}`);
+  } else {
+    write(`[${namespace}] ${message}`, context);
+  }
+}
+function createLogger(namespace) {
+  return {
+    error: (message, context) => emit("error", namespace, message, context),
+    warn: (message, context) => emit("warn", namespace, message, context),
+    info: (message, context) => emit("info", namespace, message, context),
+    debug: (message, context) => emit("debug", namespace, message, context)
+  };
+}
+export {
+  createLogger,
+  setLogLevel
+};
+//# sourceMappingURL=logger.js.map

package/dist/observability/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sources":["../../src/observability/logger.js"],"sourcesContent":["// Logger con espacio de nombres sobre console.\n//\n// Por qué un envoltorio y no una librería: corre en el navegador, son pocas líneas legibles y, cuando haga falta un\n// reporte externo (Sentry o el que sea), se enchufa en emit() sin tocar cada llamada.\n//\n// Reglas:\n//   - datos estructurados: log.warn('mensaje', {status, requestId}); nunca concatenar cadenas.\n//   - IMPORTANTE: sin datos personales. Nada de correos, nombres, contraseñas ni contenido de archivos: solo ids,\n//     códigos, status y el request_id (misma regla que el backend: logs sin datos personales).\n//   - por omisión solo salen error y warn. La aplicación pide todo en desarrollo con setLogLevel('debug') (el paquete no\n//     sabe si la aplicación corre en desarrollo: import.meta.env es de quien construye). Para ver más en una instalación\n//     ya desplegada:\n//       localStorage.setItem('calcita:logLevel', 'debug')\n//\n// Funciones puras, no renderizan: function (regla de la casa).\n\nconst LEVELS = {error: 0, warn: 1, info: 2, debug: 3};\n\nconst LOG_LEVEL_STORAGE_KEY = 'calcita:logLevel';\n\n// el nivel cuando nadie lo pidió en localStorage; lo cambia la aplicación con setLogLevel\nlet defaultLevel = LEVELS.warn;\n\n/**\n * El nivel de lo que sale en consola: 'error', 'warn', 'info' o 'debug'. Lo llama la aplicación al arrancar, por ejemplo\n * setLogLevel(import.meta.env.DEV ? 'debug' : 'warn').\n *\n * @param {'error'|'warn'|'info'|'debug'} level\n * @returns {void}\n */\nexport function setLogLevel(level) {\n    if (!(level in LEVELS)) {\n        throw new Error(`setLogLevel espera error, warn, info o debug y recibió «${level}»`);\n    }\n    defaultLevel = LEVELS[level];\n}\n\nfunction currentLevel() {\n    try {\n        const override = window.localStorage?.getItem(LOG_LEVEL_STORAGE_KEY);\n        if (override && override in LEVELS) {\n            return LEVELS[override];\n        }\n    } catch {\n        // ventana privada o almacenamiento bloqueado: usamos el nivel por defecto\n    }\n    return defaultLevel;\n}\n\nfunction emit(level, namespace, message, context) {\n    if (LEVELS[level] > currentLevel()) {\n        return;\n    }\n\n    // OJO: debug sale por console.log a propósito; console.debug cae en \"Verbose\" y DevTools lo esconde\n    const write = level === 'debug' ? console.log : (console[level] ?? console.log);\n    if (context === undefined) {\n        write(`[${namespace}] ${message}`);\n    } else {\n        write(`[${namespace}] ${message}`, context);\n    }\n}\n\n/**\n * Logger que antepone [namespace] a cada mensaje.\n *\n * @param {string} namespace p. ej. 'api', 'session'\n */\nexport function createLogger(namespace) {\n    return {\n        error: (message, context) => emit('error', namespace, message, context),\n        warn: (message, context) => emit('warn', namespace, message, context),\n        info: (message, context) => emit('info', namespace, message, context),\n        debug: (message, context) => emit('debug', namespace, message, context),\n    };\n}\n"],"names":[],"mappings":"AAgBA,MAAM,SAAS,EAAC,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAA;AAEnD,MAAM,wBAAwB;AAG9B,IAAI,eAAe,OAAO;AASnB,SAAS,YAAY,OAAO;AAC/B,MAAI,EAAE,SAAS,SAAS;AACpB,UAAM,IAAI,MAAM,2DAA2D,KAAK,GAAG;AAAA,EACvF;AACA,iBAAe,OAAO,KAAK;AAC/B;AAEA,SAAS,eAAe;AACpB,MAAI;AACA,UAAM,WAAW,OAAO,cAAc,QAAQ,qBAAqB;AACnE,QAAI,YAAY,YAAY,QAAQ;AAChC,aAAO,OAAO,QAAQ;AAAA,IAC1B;AAAA,EACJ,QAAQ;AAAA,EAER;AACA,SAAO;AACX;AAEA,SAAS,KAAK,OAAO,WAAW,SAAS,SAAS;AAC9C,MAAI,OAAO,KAAK,IAAI,gBAAgB;AAChC;AAAA,EACJ;AAGA,QAAM,QAAQ,UAAU,UAAU,QAAQ,MAAO,QAAQ,KAAK,KAAK,QAAQ;AAC3E,MAAI,YAAY,QAAW;AACvB,UAAM,IAAI,SAAS,KAAK,OAAO,EAAE;AAAA,EACrC,OAAO;AACH,UAAM,IAAI,SAAS,KAAK,OAAO,IAAI,OAAO;AAAA,EAC9C;AACJ;AAOO,SAAS,aAAa,WAAW;AACpC,SAAO;AAAA,IACH,OAAO,CAAC,SAAS,YAAY,KAAK,SAAS,WAAW,SAAS,OAAO;AAAA,IACtE,MAAM,CAAC,SAAS,YAAY,KAAK,QAAQ,WAAW,SAAS,OAAO;AAAA,IACpE,MAAM,CAAC,SAAS,YAAY,KAAK,QAAQ,WAAW,SAAS,OAAO;AAAA,IACpE,OAAO,CAAC,SAAS,YAAY,KAAK,SAAS,WAAW,SAAS,OAAO;AAAA,EAAA;AAE9E;"}

package/dist/observability/publishedBuild.js

@@ -0,0 +1,39 @@
+"use client";
+import { useSyncExternalStore } from "react";
+import { toolkitSettings } from "../toolkit/toolkitSettings.js";
+const listeners = /* @__PURE__ */ new Set();
+let newBuildPublished = false;
+function isAnotherBuild(runningBuildId, publishedBuildId) {
+  if (!runningBuildId || !publishedBuildId) {
+    return false;
+  }
+  return runningBuildId !== publishedBuildId;
+}
+function reportPublishedBuild(publishedBuildId, runningBuildId = toolkitSettings().buildId) {
+  if (newBuildPublished || !isAnotherBuild(runningBuildId, publishedBuildId)) {
+    return;
+  }
+  newBuildPublished = true;
+  listeners.forEach((listener) => listener());
+}
+function isNewBuildPublished() {
+  return newBuildPublished;
+}
+function subscribeToNewBuild(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function isNewBuildPublishedOnServer() {
+  return false;
+}
+function useNewBuildPublished() {
+  return useSyncExternalStore(subscribeToNewBuild, isNewBuildPublished, isNewBuildPublishedOnServer);
+}
+export {
+  isAnotherBuild,
+  isNewBuildPublished,
+  reportPublishedBuild,
+  subscribeToNewBuild,
+  useNewBuildPublished
+};
+//# sourceMappingURL=publishedBuild.js.map

package/dist/observability/publishedBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publishedBuild.js","sources":["../../src/observability/publishedBuild.js"],"sourcesContent":["// «Hay una versión nueva»: saber cuándo se publicó una compilación del front distinta a la que corre en esta pestaña.\n//\n// Una pestaña que lleva horas abierta sigue corriendo el front con que se abrió. Dos datos lo resuelven, y los dos los\n// pone el proyecto:\n//   - la compilación de ESTA pestaña: la prop buildId de ToolkitProvider (de una variable de entorno al construir, o la\n//     que escribe el servidor en la página al abrirla);\n//   - la compilación PUBLICADA: el servidor la anuncia en cada respuesta del API (por ejemplo, en un header) y el cliente\n//     HTTP del proyecto se la entrega aquí con reportPublishedBuild.\n// Cuando llega una distinta a la de la pestaña, el aviso (NewBuildNotice) se prende y ya no se apaga: lo único que lo\n// quita es recargar, que trae la compilación nueva.\n//\n// No hace peticiones propias: se entera con las respuestas que las pantallas ya piden.\n//\n//   axiosClient.interceptors.response.use((response) => {\n//       reportPublishedBuild(response.headers['x-frontend-build']);\n//       return response;\n//   });\n//\n// Funciones puras y un hook genérico: function (regla de la casa).\nimport {useSyncExternalStore} from 'react';\nimport {toolkitSettings} from '@/toolkit/toolkitSettings.js';\n\n// quién quiere enterarse cuando el aviso se prende (los componentes que usan useNewBuildPublished)\nconst listeners = new Set();\nlet newBuildPublished = false;\n\n/**\n * Si el servidor publica una compilación distinta a la que corre en la pestaña.\n *\n * @param {string|null|undefined} runningBuildId compilación de esta pestaña; vacía en desarrollo\n * @param {string|null|undefined} publishedBuildId compilación que anuncia el servidor; vacía si la respuesta no la trae\n * @returns {boolean} false si falta cualquiera de los dos: sin los dos no hay nada que comparar\n */\nexport function isAnotherBuild(runningBuildId, publishedBuildId) {\n    // guard clause: en desarrollo no hay compilación, y una respuesta sin el dato no dice nada\n    if (!runningBuildId || !publishedBuildId) {\n        return false;\n    }\n    return runningBuildId !== publishedBuildId;\n}\n\n/**\n * Recibe la compilación que anunció una respuesta del servidor y prende el aviso si ya no es la de la pestaña.\n *\n * @param {string|null|undefined} publishedBuildId la que anunció la respuesta\n * @param {string|null|undefined} [runningBuildId] la de esta pestaña; por omisión, el buildId de ToolkitProvider\n * @returns {void}\n */\nexport function reportPublishedBuild(publishedBuildId, runningBuildId = toolkitSettings().buildId) {\n    // guard clause: el aviso ya está prendido, o la publicada sigue siendo la de la pestaña\n    if (newBuildPublished || !isAnotherBuild(runningBuildId, publishedBuildId)) {\n        return;\n    }\n    newBuildPublished = true;\n    listeners.forEach((listener) => listener());\n}\n\n/**\n * Si ya se supo que hay una compilación nueva publicada.\n *\n * @returns {boolean}\n */\nexport function isNewBuildPublished() {\n    return newBuildPublished;\n}\n\n/**\n * Avisa a quien se suscriba cuando el aviso se prende (contrato de useSyncExternalStore).\n *\n * @param {() => void} listener función que se llama al prenderse\n * @returns {() => void} función para dejar de escuchar\n */\nexport function subscribeToNewBuild(listener) {\n    listeners.add(listener);\n    return () => listeners.delete(listener);\n}\n\n/**\n * Pintando en el servidor (Next.js) no hay pestaña que comparar: sin aviso.\n *\n * @returns {boolean}\n */\nfunction isNewBuildPublishedOnServer() {\n    return false;\n}\n\n/**\n * Para un componente: si hay una compilación nueva publicada. El componente se vuelve a pintar cuando el aviso se prende.\n *\n * @returns {boolean}\n */\nexport function useNewBuildPublished() {\n    return useSyncExternalStore(subscribeToNewBuild, isNewBuildPublished, isNewBuildPublishedOnServer);\n}\n"],"names":[],"mappings":";;;AAuBA,MAAM,YAAY,oBAAI,IAAG;AACzB,IAAI,oBAAoB;AASjB,SAAS,eAAe,gBAAgB,kBAAkB;AAE7D,MAAI,CAAC,kBAAkB,CAAC,kBAAkB;AACtC,WAAO;AAAA,EACX;AACA,SAAO,mBAAmB;AAC9B;AASO,SAAS,qBAAqB,kBAAkB,iBAAiB,gBAAe,EAAG,SAAS;AAE/F,MAAI,qBAAqB,CAAC,eAAe,gBAAgB,gBAAgB,GAAG;AACxE;AAAA,EACJ;AACA,sBAAoB;AACpB,YAAU,QAAQ,CAAC,aAAa,SAAQ,CAAE;AAC9C;AAOO,SAAS,sBAAsB;AAClC,SAAO;AACX;AAQO,SAAS,oBAAoB,UAAU;AAC1C,YAAU,IAAI,QAAQ;AACtB,SAAO,MAAM,UAAU,OAAO,QAAQ;AAC1C;AAOA,SAAS,8BAA8B;AACnC,SAAO;AACX;AAOO,SAAS,uBAAuB;AACnC,SAAO,qBAAqB,qBAAqB,qBAAqB,2BAA2B;AACrG;"}

package/dist/observability/usePublishedBuildWatch.js

@@ -0,0 +1,77 @@
+"use client";
+import { useEffect } from "react";
+import { publishedBuildIdOf, buildWatchActionOf, BUILD_WATCH_ACTION } from "./buildWatch.js";
+import { createLogger } from "./logger.js";
+import { reportPublishedBuild } from "./publishedBuild.js";
+import { toolkitSettings } from "../toolkit/toolkitSettings.js";
+const log = createLogger("build-watch");
+const MILLISECONDS_PER_MINUTE = 60 * 1e3;
+const DEFAULT_CHECK_EVERY_MINUTES = 5;
+const DEFAULT_RELOAD_AFTER_HIDDEN_MINUTES = 15;
+function reloadPage() {
+  window.location.reload();
+}
+function usePublishedBuildWatch({
+  url = null,
+  buildId,
+  checkEveryMinutes = DEFAULT_CHECK_EVERY_MINUTES,
+  reloadAfterHiddenMinutes = DEFAULT_RELOAD_AFTER_HIDDEN_MINUTES,
+  onReload = reloadPage
+} = {}) {
+  useEffect(() => {
+    if (!url || typeof document === "undefined") {
+      return void 0;
+    }
+    let hiddenSince = null;
+    let isChecking = false;
+    const check = async (hiddenMilliseconds = 0) => {
+      if (isChecking) {
+        return;
+      }
+      isChecking = true;
+      try {
+        const response = await fetch(url, { cache: "no-store", headers: { Accept: "application/json" } });
+        const publishedBuildId = response.ok ? publishedBuildIdOf(await response.json()) : null;
+        const action = buildWatchActionOf({
+          runningBuildId: buildId ?? toolkitSettings().buildId,
+          publishedBuildId,
+          hiddenMilliseconds,
+          reloadAfterHiddenMilliseconds: reloadAfterHiddenMinutes === null ? null : reloadAfterHiddenMinutes * MILLISECONDS_PER_MINUTE
+        });
+        if (action === BUILD_WATCH_ACTION.reload) {
+          onReload();
+        } else if (action === BUILD_WATCH_ACTION.notice) {
+          reportPublishedBuild(publishedBuildId, buildId ?? toolkitSettings().buildId);
+        }
+      } catch (error) {
+        log.info("No se pudo revisar la versión publicada", { url, reason: error.message });
+      } finally {
+        isChecking = false;
+      }
+    };
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        hiddenSince = Date.now();
+        return;
+      }
+      const hiddenMilliseconds = hiddenSince === null ? 0 : Date.now() - hiddenSince;
+      hiddenSince = null;
+      check(hiddenMilliseconds);
+    };
+    const timer = window.setInterval(() => {
+      if (document.visibilityState === "visible") {
+        check();
+      }
+    }, checkEveryMinutes * MILLISECONDS_PER_MINUTE);
+    check();
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      window.clearInterval(timer);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [url, buildId, checkEveryMinutes, reloadAfterHiddenMinutes, onReload]);
+}
+export {
+  usePublishedBuildWatch
+};
+//# sourceMappingURL=usePublishedBuildWatch.js.map

package/dist/observability/usePublishedBuildWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePublishedBuildWatch.js","sources":["../../src/observability/usePublishedBuildWatch.js"],"sourcesContent":["// Que la app se entere sola de que se publicó otra versión del front, sin depender del API. Hace falta sobre todo con la\n// app anclada al inicio del iPhone: al abrirla, el iPhone NO vuelve a pedir la página, retoma la que tenía en memoria (aunque\n// haya pasado un día), así que la persona se quedaba con la versión vieja hasta cerrarla a la fuerza.\n//\n// Cómo: al construir, el proyecto deja un archivo con su versión ({\"buildId\": \"…\"}, por omisión /version.json) y la misma\n// versión en ToolkitProvider (buildId). Esta app vuelve a leer el archivo:\n//   - cada vez que regresa del segundo plano (justo cuando el iPhone la despierta), y\n//   - cada tanto mientras se usa (checkEveryMinutes).\n// Si ya hay otra (buildWatchActionOf): si estuvo fuera al menos reloadAfterHiddenMinutes, se recarga sola; si no, sale el\n// aviso «Hay una versión nueva · Actualizar» (NewBuildNotice, que el marco ya pinta) para no borrar lo que llevaba escrito.\n//\n// Se monta UNA vez, en la raíz de la app, con la versión de la pestaña (la misma que va a ToolkitProvider buildId):\n//   usePublishedBuildWatch({url: import.meta.env.PROD ? '/version.json' : null, buildId: APP_BUILD_ID});\n// Sin url no hace nada (en desarrollo no hay versión que comparar).\n//\n// OJO buildId: sin él se toma el de ToolkitProvider, pero la raíz suele montar este gancho ANTES de que ToolkitProvider se\n// pinte (AccountProvider lo pinta hasta tener la sesión): la primera revisión no tenía con qué comparar y, al abrir la app\n// en la pantalla de entrar, el aviso no salía (medido en el proyecto que arma calcita new).\n//\n// OJO: el archivo se pide con cache 'no-store' y el servidor no debe guardarlo (en el nginx de los ejemplos, «location /»\n// ya va con no-cache). Sin red (el teléfono en el metro) no pasa nada: se vuelve a intentar en la siguiente revisión.\n//\n// Gancho genérico del paquete: function (regla de la casa).\nimport {useEffect} from 'react';\n\nimport {BUILD_WATCH_ACTION, buildWatchActionOf, publishedBuildIdOf} from '@/observability/buildWatch.js';\nimport {createLogger} from '@/observability/logger.js';\nimport {reportPublishedBuild} from '@/observability/publishedBuild.js';\nimport {toolkitSettings} from '@/toolkit/toolkitSettings.js';\n\nconst log = createLogger('build-watch');\nconst MILLISECONDS_PER_MINUTE = 60 * 1000;\n// por omisión: revisar cada 5 minutos mientras se usa, y recargar sola si estuvo fuera 15 minutos o más\nconst DEFAULT_CHECK_EVERY_MINUTES = 5;\nconst DEFAULT_RELOAD_AFTER_HIDDEN_MINUTES = 15;\n\n/** Lo que hace si el proyecto no dice otra cosa: recargar la página, que trae la versión nueva. */\nfunction reloadPage() {\n    window.location.reload();\n}\n\n/**\n * @param {object} [options]\n * @param {string|null} [options.url] dónde está el archivo de versión ({\"buildId\": \"…\"}); null: no vigila\n * @param {string} [options.buildId] la versión de esta pestaña; por omisión el buildId de ToolkitProvider (ver el OJO)\n * @param {number} [options.checkEveryMinutes] cada cuánto revisa mientras se usa; por omisión 5\n * @param {number|null} [options.reloadAfterHiddenMinutes] desde cuántos minutos fuera se recarga sola al volver; por\n *     omisión 15. null: nunca se recarga sola, siempre el aviso\n * @param {() => void} [options.onReload] cómo recargar (p. ej. guardar un borrador antes). OJO: con useCallback; una\n *     función nueva en cada pintada volvería a armar la vigilancia\n * @returns {void}\n */\nexport function usePublishedBuildWatch({\n    url = null, buildId, checkEveryMinutes = DEFAULT_CHECK_EVERY_MINUTES, reloadAfterHiddenMinutes = DEFAULT_RELOAD_AFTER_HIDDEN_MINUTES, onReload = reloadPage,\n} = {}) {\n    useEffect(() => {\n        if (!url || typeof document === 'undefined') {\n            return undefined;\n        }\n        let hiddenSince = null;\n        let isChecking = false;\n\n        const check = async (hiddenMilliseconds = 0) => {\n            // una revisión a la vez: al volver del segundo plano pueden llegar dos avisos del navegador juntos\n            if (isChecking) {\n                return;\n            }\n            isChecking = true;\n            try {\n                const response = await fetch(url, {cache: 'no-store', headers: {Accept: 'application/json'}});\n                const publishedBuildId = response.ok ? publishedBuildIdOf(await response.json()) : null;\n                const action = buildWatchActionOf({\n                    runningBuildId: buildId ?? toolkitSettings().buildId,\n                    publishedBuildId,\n                    hiddenMilliseconds,\n                    reloadAfterHiddenMilliseconds: reloadAfterHiddenMinutes === null ? null : reloadAfterHiddenMinutes * MILLISECONDS_PER_MINUTE,\n                });\n                if (action === BUILD_WATCH_ACTION.reload) {\n                    onReload();\n                } else if (action === BUILD_WATCH_ACTION.notice) {\n                    reportPublishedBuild(publishedBuildId, buildId ?? toolkitSettings().buildId);\n                }\n            } catch (error) {\n                // sin red o con un archivo que no es JSON: no es algo que la persona pueda arreglar; queda en el registro\n                log.info('No se pudo revisar la versión publicada', {url, reason: error.message});\n            } finally {\n                isChecking = false;\n            }\n        };\n\n        // al irse a segundo plano se anota la hora; al volver se revisa con cuánto tiempo estuvo fuera\n        const handleVisibilityChange = () => {\n            if (document.visibilityState === 'hidden') {\n                hiddenSince = Date.now();\n                return;\n            }\n            const hiddenMilliseconds = hiddenSince === null ? 0 : Date.now() - hiddenSince;\n            hiddenSince = null;\n            check(hiddenMilliseconds);\n        };\n        // mientras se usa (en segundo plano el teléfono detiene los relojes de la página de todos modos)\n        const timer = window.setInterval(() => {\n            if (document.visibilityState === 'visible') {\n                check();\n            }\n        }, checkEveryMinutes * MILLISECONDS_PER_MINUTE);\n\n        check();\n        document.addEventListener('visibilitychange', handleVisibilityChange);\n        return () => {\n            window.clearInterval(timer);\n            document.removeEventListener('visibilitychange', handleVisibilityChange);\n        };\n    }, [url, buildId, checkEveryMinutes, reloadAfterHiddenMinutes, onReload]);\n}\n"],"names":[],"mappings":";;;;;;AA8BA,MAAM,MAAM,aAAa,aAAa;AACtC,MAAM,0BAA0B,KAAK;AAErC,MAAM,8BAA8B;AACpC,MAAM,sCAAsC;AAG5C,SAAS,aAAa;AAClB,SAAO,SAAS,OAAA;AACpB;AAaO,SAAS,uBAAuB;AAAA,EACnC,MAAM;AAAA,EAAM;AAAA,EAAS,oBAAoB;AAAA,EAA6B,2BAA2B;AAAA,EAAqC,WAAW;AACrJ,IAAI,IAAI;AACJ,YAAU,MAAM;AACZ,QAAI,CAAC,OAAO,OAAO,aAAa,aAAa;AACzC,aAAO;AAAA,IACX;AACA,QAAI,cAAc;AAClB,QAAI,aAAa;AAEjB,UAAM,QAAQ,OAAO,qBAAqB,MAAM;AAE5C,UAAI,YAAY;AACZ;AAAA,MACJ;AACA,mBAAa;AACb,UAAI;AACA,cAAM,WAAW,MAAM,MAAM,KAAK,EAAC,OAAO,YAAY,SAAS,EAAC,QAAQ,mBAAA,EAAkB,CAAE;AAC5F,cAAM,mBAAmB,SAAS,KAAK,mBAAmB,MAAM,SAAS,KAAA,CAAM,IAAI;AACnF,cAAM,SAAS,mBAAmB;AAAA,UAC9B,gBAAgB,WAAW,gBAAA,EAAkB;AAAA,UAC7C;AAAA,UACA;AAAA,UACA,+BAA+B,6BAA6B,OAAO,OAAO,2BAA2B;AAAA,QAAA,CACxG;AACD,YAAI,WAAW,mBAAmB,QAAQ;AACtC,mBAAA;AAAA,QACJ,WAAW,WAAW,mBAAmB,QAAQ;AAC7C,+BAAqB,kBAAkB,WAAW,gBAAA,EAAkB,OAAO;AAAA,QAC/E;AAAA,MACJ,SAAS,OAAO;AAEZ,YAAI,KAAK,2CAA2C,EAAC,KAAK,QAAQ,MAAM,SAAQ;AAAA,MACpF,UAAA;AACI,qBAAa;AAAA,MACjB;AAAA,IACJ;AAGA,UAAM,yBAAyB,MAAM;AACjC,UAAI,SAAS,oBAAoB,UAAU;AACvC,sBAAc,KAAK,IAAA;AACnB;AAAA,MACJ;AACA,YAAM,qBAAqB,gBAAgB,OAAO,IAAI,KAAK,QAAQ;AACnE,oBAAc;AACd,YAAM,kBAAkB;AAAA,IAC5B;AAEA,UAAM,QAAQ,OAAO,YAAY,MAAM;AACnC,UAAI,SAAS,oBAAoB,WAAW;AACxC,cAAA;AAAA,MACJ;AAAA,IACJ,GAAG,oBAAoB,uBAAuB;AAE9C,UAAA;AACA,aAAS,iBAAiB,oBAAoB,sBAAsB;AACpE,WAAO,MAAM;AACT,aAAO,cAAc,KAAK;AAC1B,eAAS,oBAAoB,oBAAoB,sBAAsB;AAAA,IAC3E;AAAA,EACJ,GAAG,CAAC,KAAK,SAAS,mBAAmB,0BAA0B,QAAQ,CAAC;AAC5E;"}

package/dist/passkeys.js

@@ -0,0 +1,7 @@
+import { createPasskey, passkeysSupported, signWithPasskey } from "./security/passkeys.js";
+export {
+  createPasskey,
+  passkeysSupported,
+  signWithPasskey
+};
+//# sourceMappingURL=passkeys.js.map

package/dist/passkeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/periodRanges.js

@@ -0,0 +1,33 @@
+function positionOf(options, value) {
+  return options.findIndex((option) => option.value === value);
+}
+function rangeEndOptionsOf(options, from) {
+  const fromPosition = positionOf(options, from);
+  if (fromPosition === -1) {
+    return options;
+  }
+  let rangeIsBroken = false;
+  return options.map((option, position) => {
+    if (position > fromPosition && option.disabled) {
+      rangeIsBroken = true;
+    }
+    return { ...option, disabled: position < fromPosition || rangeIsBroken || option.disabled };
+  });
+}
+function periodRangeIsValid(options, from, to) {
+  const fromPosition = positionOf(options, from);
+  const toPosition = positionOf(options, to);
+  if (fromPosition === -1 || toPosition === -1 || toPosition < fromPosition) {
+    return false;
+  }
+  return options.slice(fromPosition, toPosition + 1).every((option) => !option.disabled);
+}
+function rangeEndAfterStartChange(options, from, to) {
+  return periodRangeIsValid(options, from, to) ? to : from;
+}
+export {
+  periodRangeIsValid,
+  rangeEndAfterStartChange,
+  rangeEndOptionsOf
+};
+//# sourceMappingURL=periodRanges.js.map

package/dist/periodRanges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"periodRanges.js","sources":["../src/periodRanges.js"],"sourcesContent":["// Las reglas de un rango de periodos (de tal quincena a tal quincena, de tal mes a tal mes) sobre una lista ORDENADA de\n// opciones, cada una con su valor y si se puede elegir.\n//\n// Un rango vale si sus dos extremos se pueden elegir, «hasta» no va antes de «desde» y NINGUNA opción de en medio está\n// apagada: no se cruza un periodo roto. Por eso la lista de «hasta» se corta en la primera opción apagada después de\n// «desde».\n//\n// No sabe de quincenas ni de productos: quien la usa le pasa sus opciones ya ordenadas. Funciones puras, sin React: se\n// prueban con node --test.\n//\n// Genérico del paquete: function (regla de la casa).\n\n/**\n * @typedef {{value: string, disabled: boolean}} PeriodOption\n */\n\n/**\n * Dónde está un valor en la lista.\n *\n * @param {PeriodOption[]} options en orden\n * @param {string|null|undefined} value\n * @returns {number} su posición; -1 si no está\n */\nfunction positionOf(options, value) {\n    return options.findIndex((option) => option.value === value);\n}\n\n/**\n * Las opciones de «hasta» para un «desde»: apagadas las de antes de «desde» y todas desde la primera apagada después de\n * él (un rango no salta un periodo roto).\n *\n * @param {PeriodOption[]} options en orden\n * @param {string|null|undefined} from el «desde» elegido; sin él, las opciones tal cual\n * @returns {PeriodOption[]} las mismas opciones, con disabled donde no se puede terminar el rango\n */\nexport function rangeEndOptionsOf(options, from) {\n    const fromPosition = positionOf(options, from);\n\n    // guard clause: sin «desde» no hay nada que cortar\n    if (fromPosition === -1) {\n        return options;\n    }\n\n    let rangeIsBroken = false;\n\n    return options.map((option, position) => {\n        if (position > fromPosition && option.disabled) {\n            rangeIsBroken = true;\n        }\n\n        return {...option, disabled: position < fromPosition || rangeIsBroken || option.disabled};\n    });\n}\n\n/**\n * Si un rango se puede pedir.\n *\n * @param {PeriodOption[]} options en orden\n * @param {string|null|undefined} from\n * @param {string|null|undefined} to\n * @returns {boolean} true si los dos extremos existen, se pueden elegir, van en orden y no hay nada apagado en medio\n */\nexport function periodRangeIsValid(options, from, to) {\n    const fromPosition = positionOf(options, from);\n    const toPosition = positionOf(options, to);\n\n    // guard clause: un extremo que no existe o un rango al revés no vale\n    if (fromPosition === -1 || toPosition === -1 || toPosition < fromPosition) {\n        return false;\n    }\n\n    return options.slice(fromPosition, toPosition + 1).every((option) => !option.disabled);\n}\n\n/**\n * El «hasta» que queda al cambiar «desde»: el mismo si el rango sigue valiendo; si no, el propio «desde» (un rango de un\n * solo periodo siempre vale).\n *\n * @param {PeriodOption[]} options en orden\n * @param {string} from el «desde» nuevo\n * @param {string|null|undefined} to el «hasta» que había\n * @returns {string} el «hasta» que se queda\n */\nexport function rangeEndAfterStartChange(options, from, to) {\n    return periodRangeIsValid(options, from, to) ? to : from;\n}\n"],"names":[],"mappings":"AAuBA,SAAS,WAAW,SAAS,OAAO;AAChC,SAAO,QAAQ,UAAU,CAAC,WAAW,OAAO,UAAU,KAAK;AAC/D;AAUO,SAAS,kBAAkB,SAAS,MAAM;AAC7C,QAAM,eAAe,WAAW,SAAS,IAAI;AAG7C,MAAI,iBAAiB,IAAI;AACrB,WAAO;AAAA,EACX;AAEA,MAAI,gBAAgB;AAEpB,SAAO,QAAQ,IAAI,CAAC,QAAQ,aAAa;AACrC,QAAI,WAAW,gBAAgB,OAAO,UAAU;AAC5C,sBAAgB;AAAA,IACpB;AAEA,WAAO,EAAC,GAAG,QAAQ,UAAU,WAAW,gBAAgB,iBAAiB,OAAO,SAAQ;AAAA,EAC5F,CAAC;AACL;AAUO,SAAS,mBAAmB,SAAS,MAAM,IAAI;AAClD,QAAM,eAAe,WAAW,SAAS,IAAI;AAC7C,QAAM,aAAa,WAAW,SAAS,EAAE;AAGzC,MAAI,iBAAiB,MAAM,eAAe,MAAM,aAAa,cAAc;AACvE,WAAO;AAAA,EACX;AAEA,SAAO,QAAQ,MAAM,cAAc,aAAa,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,QAAQ;AACzF;AAWO,SAAS,yBAAyB,SAAS,MAAM,IAAI;AACxD,SAAO,mBAAmB,SAAS,MAAM,EAAE,IAAI,KAAK;AACxD;"}

package/dist/problems.js

@@ -0,0 +1,51 @@
+import { translateToolkit } from "./toolkit/toolkitSettings.js";
+const GENERIC_KEY_BY_STATUS = {
+  0: "offline",
+  401: "unauthenticated",
+  403: "forbidden",
+  404: "notFound",
+  409: "conflict",
+  410: "gone",
+  413: "payloadTooLarge",
+  419: "csrfTokenMismatch",
+  422: "validation",
+  429: "tooManyRequests",
+  500: "serverError",
+  502: "serviceUnavailable",
+  503: "serviceUnavailable",
+  504: "serviceUnavailable"
+};
+function genericKeyOf(status) {
+  return GENERIC_KEY_BY_STATUS[status] ?? "generic";
+}
+function problemTitle(problem, status, { translatedByServer = true } = {}) {
+  if (translatedByServer && problem?.title) {
+    return problem.title;
+  }
+  return translateToolkit("problems", `${genericKeyOf(status)}.title`);
+}
+function problemMessage(problem, status, { translatedByServer = true } = {}) {
+  if (translatedByServer && problem?.detail) {
+    return problem.detail;
+  }
+  return translateToolkit("problems", `${genericKeyOf(status)}.detail`);
+}
+function fieldErrorsOf(problem) {
+  const rawErrors = problem?.errors;
+  const errorsByField = {};
+  if (!rawErrors || typeof rawErrors !== "object" || Array.isArray(rawErrors)) {
+    return errorsByField;
+  }
+  for (const [fieldPath, messages] of Object.entries(rawErrors)) {
+    const fieldName = String(fieldPath).split(".").filter((segment) => !/^\d+$/.test(segment)).at(-1) || "_";
+    const messageList = Array.isArray(messages) ? messages : [messages];
+    errorsByField[fieldName] = [...errorsByField[fieldName] ?? [], ...messageList.map(String)];
+  }
+  return errorsByField;
+}
+export {
+  fieldErrorsOf,
+  problemMessage,
+  problemTitle
+};
+//# sourceMappingURL=problems.js.map

package/dist/problems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"problems.js","sources":["../src/problems.js"],"sourcesContent":["// Del error RFC 9457 del backend al texto que lee la persona.\n//\n// La regla tiene dos mitades:\n//   - Lo que YA viene traducido se usa tal cual. Un backend que responde RFC 9457 manda title y detail en el idioma del\n//     header Accept-Language, y los errores de validación (422, como los de Laravel) traen `errors` como\n//     {campo: [mensajes]} también traducidos. Traducir aquí por `code` pisaría el texto que el backend escribió\n//     para ESE caso (p. ej. \"Correo o contraseña incorrectos\").\n//   - Lo genérico se traduce aquí, con los textos del paquete (namespace problems): sin red (no hubo respuesta), un\n//     502 del proxy que llega en HTML, o un error que armó el servidor web por su cuenta en otro idioma.\n//\n// OJO: estas funciones se llaman fuera de los componentes: leen el idioma y los textos de la configuración vigente\n// del proveedor.\n//\n// Funciones puras, no renderizan: function (regla de la casa).\nimport {translateToolkit} from '@/toolkit/toolkitSettings.js';\n\n// status → llave genérica de los textos del paquete (namespace problems)\nconst GENERIC_KEY_BY_STATUS = {\n    0: 'offline',\n    401: 'unauthenticated',\n    403: 'forbidden',\n    404: 'notFound',\n    409: 'conflict',\n    410: 'gone',\n    413: 'payloadTooLarge',\n    419: 'csrfTokenMismatch',\n    422: 'validation',\n    429: 'tooManyRequests',\n    500: 'serverError',\n    502: 'serviceUnavailable',\n    503: 'serviceUnavailable',\n    504: 'serviceUnavailable',\n};\n\nfunction genericKeyOf(status) {\n    return GENERIC_KEY_BY_STATUS[status] ?? 'generic';\n}\n\n/**\n * Título del problema en el idioma activo.\n *\n * @param {object|null} problem cuerpo RFC 9457 (puede faltar)\n * @param {number} status status HTTP; 0 si no hubo respuesta\n * @param {{translatedByServer?: boolean}} [options] false cuando el idioma de la respuesta no es el pedido\n * @returns {string}\n */\nexport function problemTitle(problem, status, {translatedByServer = true} = {}) {\n    if (translatedByServer && problem?.title) {\n        return problem.title;\n    }\n    return translateToolkit('problems', `${genericKeyOf(status)}.title`);\n}\n\n/**\n * Mensaje principal (detail) del problema en el idioma activo.\n *\n * @param {object|null} problem cuerpo RFC 9457 (puede faltar)\n * @param {number} status status HTTP; 0 si no hubo respuesta\n * @param {{translatedByServer?: boolean}} [options] false cuando el idioma de la respuesta no es el pedido\n * @returns {string}\n */\nexport function problemMessage(problem, status, {translatedByServer = true} = {}) {\n    if (translatedByServer && problem?.detail) {\n        return problem.detail;\n    }\n    return translateToolkit('problems', `${genericKeyOf(status)}.detail`);\n}\n\n/**\n * Errores por campo de un 422 de Laravel: {campo: ['mensaje', ...]}, ya traducidos por el backend.\n * Un campo anidado (\"rows.3.email\") se reduce a su último segmento que no es número, porque el formulario\n * conoce el campo y no la ruta.\n *\n * @param {object|null} problem cuerpo RFC 9457\n * @returns {Record<string, string[]>}\n */\nexport function fieldErrorsOf(problem) {\n    const rawErrors = problem?.errors;\n    const errorsByField = {};\n\n    // guard clause: sin errores por campo (cualquier status distinto de 422)\n    if (!rawErrors || typeof rawErrors !== 'object' || Array.isArray(rawErrors)) {\n        return errorsByField;\n    }\n\n    for (const [fieldPath, messages] of Object.entries(rawErrors)) {\n        const fieldName = String(fieldPath).split('.').filter((segment) => !/^\\d+$/.test(segment)).at(-1) || '_';\n        const messageList = Array.isArray(messages) ? messages : [messages];\n        errorsByField[fieldName] = [...(errorsByField[fieldName] ?? []), ...messageList.map(String)];\n    }\n    return errorsByField;\n}\n"],"names":[],"mappings":";AAiBA,MAAM,wBAAwB;AAAA,EAC1B,GAAG;AAAA,EACH,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AACT;AAEA,SAAS,aAAa,QAAQ;AAC1B,SAAO,sBAAsB,MAAM,KAAK;AAC5C;AAUO,SAAS,aAAa,SAAS,QAAQ,EAAC,qBAAqB,KAAI,IAAI,IAAI;AAC5E,MAAI,sBAAsB,SAAS,OAAO;AACtC,WAAO,QAAQ;AAAA,EACnB;AACA,SAAO,iBAAiB,YAAY,GAAG,aAAa,MAAM,CAAC,QAAQ;AACvE;AAUO,SAAS,eAAe,SAAS,QAAQ,EAAC,qBAAqB,KAAI,IAAI,IAAI;AAC9E,MAAI,sBAAsB,SAAS,QAAQ;AACvC,WAAO,QAAQ;AAAA,EACnB;AACA,SAAO,iBAAiB,YAAY,GAAG,aAAa,MAAM,CAAC,SAAS;AACxE;AAUO,SAAS,cAAc,SAAS;AACnC,QAAM,YAAY,SAAS;AAC3B,QAAM,gBAAgB,CAAA;AAGtB,MAAI,CAAC,aAAa,OAAO,cAAc,YAAY,MAAM,QAAQ,SAAS,GAAG;AACzE,WAAO;AAAA,EACX;AAEA,aAAW,CAAC,WAAW,QAAQ,KAAK,OAAO,QAAQ,SAAS,GAAG;AAC3D,UAAM,YAAY,OAAO,SAAS,EAAE,MAAM,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC,QAAQ,KAAK,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK;AACrG,UAAM,cAAc,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC,QAAQ;AAClE,kBAAc,SAAS,IAAI,CAAC,GAAI,cAAc,SAAS,KAAK,CAAA,GAAK,GAAG,YAAY,IAAI,MAAM,CAAC;AAAA,EAC/F;AACA,SAAO;AACX;"}

package/dist/pwa/InstallAppSetting.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import Box from "@mui/material/Box";
+import Button from "@mui/material/Button";
+import InstallMobileRoundedIcon from "@mui/icons-material/InstallMobileRounded";
+import { useToolkitTranslation } from "../toolkit/useToolkitTranslation.js";
+import { INSTALL_VARIANT } from "./installInstructions.js";
+import InstallInstructionsDialog from "./InstallInstructionsDialog.js";
+import { useInstallPrompt } from "./useInstallPrompt.js";
+import ComponentTexts from "../toolkit/ComponentTexts.js";
+function InstallAppSetting({ texts } = {}) {
+  const { t } = useToolkitTranslation("common", texts);
+  const { variant, promptInstall } = useInstallPrompt();
+  const [stepsOpen, setStepsOpen] = useState(false);
+  if (!variant) {
+    return null;
+  }
+  const handleClick = () => {
+    if (variant === INSTALL_VARIANT.native) {
+      promptInstall();
+    } else {
+      setStepsOpen(true);
+    }
+  };
+  return /* @__PURE__ */ jsx(ComponentTexts, { namespace: "common", texts, children: /* @__PURE__ */ jsxs(Box, { sx: { px: 1, py: 0.5 }, children: [
+    /* @__PURE__ */ jsx(Button, { fullWidth: true, variant: "outlined", startIcon: /* @__PURE__ */ jsx(InstallMobileRoundedIcon, {}), onClick: handleClick, children: t("install.menuLabel") }),
+    /* @__PURE__ */ jsx(InstallInstructionsDialog, { variant, open: stepsOpen, onClose: () => setStepsOpen(false) })
+  ] }) });
+}
+export {
+  InstallAppSetting as default
+};
+//# sourceMappingURL=InstallAppSetting.js.map

package/dist/pwa/InstallAppSetting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstallAppSetting.js","sources":["../../src/pwa/InstallAppSetting.jsx"],"sourcesContent":["// «Instalar la app» dentro del menú de la cuenta (accountSettings de AppLayout): para quien dijo «Ahora no» a la invitación\n// y después sí la quiere. No respeta el «Ahora no» (aquí la persona la busca a propósito). Ya instalada o sin manera de\n// instalar en ese equipo, no pinta nada.\n//\n// El diálogo de los pasos va aquí mismo: el menú de la cuenta se queda abierto mientras se ve, y al cerrarlo se regresa al\n// menú.\n//\n// Genérico del paquete: function (regla de la casa).\nimport {useState} from 'react';\nimport Box from '@mui/material/Box';\nimport Button from '@mui/material/Button';\nimport InstallMobileRoundedIcon from '@mui/icons-material/InstallMobileRounded';\n\nimport {useToolkitTranslation} from '@/toolkit/useToolkitTranslation.js';\nimport {INSTALL_VARIANT} from '@/pwa/installInstructions.js';\nimport InstallInstructionsDialog from '@/pwa/InstallInstructionsDialog.jsx';\nimport {useInstallPrompt} from '@/pwa/useInstallPrompt.js';\nimport ComponentTexts from '@/toolkit/ComponentTexts.jsx';\n\n/**\n * @param {object} [props]\n * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete\n */\nexport default function InstallAppSetting({texts} = {}) {\n    const {t} = useToolkitTranslation('common', texts);\n    const {variant, promptInstall} = useInstallPrompt();\n    const [stepsOpen, setStepsOpen] = useState(false);\n\n    if (!variant) {\n        return null;\n    }\n\n    const handleClick = () => {\n        if (variant === INSTALL_VARIANT.native) {\n            promptInstall();\n        } else {\n            setStepsOpen(true);\n        }\n    };\n\n    return (\n        <ComponentTexts namespace=\"common\" texts={texts}>\n            <Box sx={{px: 1, py: 0.5}}>\n                <Button fullWidth variant=\"outlined\" startIcon={<InstallMobileRoundedIcon />} onClick={handleClick}>\n                    {t('install.menuLabel')}\n                </Button>\n                <InstallInstructionsDialog variant={variant} open={stepsOpen} onClose={() => setStepsOpen(false)} />\n            </Box>\n        </ComponentTexts>\n    );\n}\n"],"names":[],"mappings":";;;;;;;;;;;AAuBA,SAAwB,kBAAkB,EAAC,MAAA,IAAS,IAAI;AACpD,QAAM,EAAC,EAAA,IAAK,sBAAsB,UAAU,KAAK;AACjD,QAAM,EAAC,SAAS,cAAA,IAAiB,iBAAA;AACjC,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAEhD,MAAI,CAAC,SAAS;AACV,WAAO;AAAA,EACX;AAEA,QAAM,cAAc,MAAM;AACtB,QAAI,YAAY,gBAAgB,QAAQ;AACpC,oBAAA;AAAA,IACJ,OAAO;AACH,mBAAa,IAAI;AAAA,IACrB;AAAA,EACJ;AAEA,SACI,oBAAC,gBAAA,EAAe,WAAU,UAAS,OAC/B,UAAA,qBAAC,KAAA,EAAI,IAAI,EAAC,IAAI,GAAG,IAAI,OACjB,UAAA;AAAA,IAAA,oBAAC,QAAA,EAAO,WAAS,MAAC,SAAQ,YAAW,WAAW,oBAAC,0BAAA,CAAA,CAAyB,GAAI,SAAS,aAClF,UAAA,EAAE,mBAAmB,GAC1B;AAAA,IACA,oBAAC,6BAA0B,SAAkB,MAAM,WAAW,SAAS,MAAM,aAAa,KAAK,EAAA,CAAG;AAAA,EAAA,EAAA,CACtG,EAAA,CACJ;AAER;"}

package/dist/pwa/InstallInstructionsDialog.js

@@ -0,0 +1,35 @@
+"use client";
+import { jsxs, jsx } from "react/jsx-runtime";
+import Button from "@mui/material/Button";
+import Dialog from "@mui/material/Dialog";
+import DialogActions from "@mui/material/DialogActions";
+import DialogContent from "@mui/material/DialogContent";
+import DialogTitle from "@mui/material/DialogTitle";
+import Typography from "@mui/material/Typography";
+import { useToolkitTranslation } from "../toolkit/useToolkitTranslation.js";
+import { INSTALL_VARIANT } from "./installInstructions.js";
+const STEPS_BY_VARIANT = Object.freeze({
+  [INSTALL_VARIANT.iosModern]: ["step1", "step2", "step3", "step4"],
+  [INSTALL_VARIANT.iosClassic]: ["step1", "step2", "step3"],
+  [INSTALL_VARIANT.androidFirefox]: ["step1", "step2", "step3"]
+});
+function variantHasInstructions(variant) {
+  return Boolean(STEPS_BY_VARIANT[variant]);
+}
+function InstallInstructionsDialog({ variant, open, onClose, texts }) {
+  const { t } = useToolkitTranslation("common", texts);
+  const steps = STEPS_BY_VARIANT[variant];
+  if (!steps) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Dialog, { open, onClose, maxWidth: "xs", fullWidth: true, children: [
+    /* @__PURE__ */ jsx(DialogTitle, { children: t(`install.${variant}.title`) }),
+    /* @__PURE__ */ jsx(DialogContent, { children: /* @__PURE__ */ jsx(Typography, { component: "ol", sx: { m: 0, pl: 3, display: "grid", gap: 1.25 }, children: steps.map((step) => /* @__PURE__ */ jsx(Typography, { component: "li", variant: "body1", children: t(`install.${variant}.${step}`) }, step)) }) }),
+    /* @__PURE__ */ jsx(DialogActions, { children: /* @__PURE__ */ jsx(Button, { variant: "contained", onClick: onClose, children: t("install.gotIt") }) })
+  ] });
+}
+export {
+  InstallInstructionsDialog as default,
+  variantHasInstructions
+};
+//# sourceMappingURL=InstallInstructionsDialog.js.map

package/dist/pwa/InstallInstructionsDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstallInstructionsDialog.js","sources":["../../src/pwa/InstallInstructionsDialog.jsx"],"sourcesContent":["// Los pasos para instalar la app a mano, según el equipo (iOS 26 cambió el camino; Firefox usa su propio menú). Lo usan la\n// invitación (InstallPromptBanner) y la entrada del menú de la cuenta (InstallAppSetting): los dos abren el mismo diálogo.\n// Si la variante no lleva pasos (el navegador tiene su propio diálogo, o no hay nada que ofrecer) no pinta nada.\n//\n// OJO, para quien lo monte: NO dentro de un Menu de MUI que se cierra; el Menu quita a sus hijos al cerrarse y el diálogo\n// nunca aparecería. Va junto al Menu o en un lugar que se quede pintado.\n//\n// Genérico del paquete: function (regla de la casa).\nimport Button from '@mui/material/Button';\nimport Dialog from '@mui/material/Dialog';\nimport DialogActions from '@mui/material/DialogActions';\nimport DialogContent from '@mui/material/DialogContent';\nimport DialogTitle from '@mui/material/DialogTitle';\nimport Typography from '@mui/material/Typography';\n\nimport {useToolkitTranslation} from '@/toolkit/useToolkitTranslation.js';\nimport {INSTALL_VARIANT} from '@/pwa/installInstructions.js';\n\n// cada variante con pasos a mano → su título y sus pasos en los textos del paquete (common:install.<variante>)\nconst STEPS_BY_VARIANT = Object.freeze({\n    [INSTALL_VARIANT.iosModern]: ['step1', 'step2', 'step3', 'step4'],\n    [INSTALL_VARIANT.iosClassic]: ['step1', 'step2', 'step3'],\n    [INSTALL_VARIANT.androidFirefox]: ['step1', 'step2', 'step3'],\n});\n\n/**\n * ¿Esta variante se instala con pasos a mano (y no con el diálogo del navegador)?\n *\n * @param {string|null} variant\n * @returns {boolean}\n */\nexport function variantHasInstructions(variant) {\n    return Boolean(STEPS_BY_VARIANT[variant]);\n}\n\n/**\n * @param {object} props\n * @param {string|null} props.variant una de INSTALL_VARIANT (useInstallPrompt)\n * @param {boolean} props.open\n * @param {() => void} props.onClose\n * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete\n */\nexport default function InstallInstructionsDialog({variant, open, onClose, texts}) {\n    const {t} = useToolkitTranslation('common', texts);\n    const steps = STEPS_BY_VARIANT[variant];\n    if (!steps) {\n        return null;\n    }\n\n    return (\n        <Dialog open={open} onClose={onClose} maxWidth=\"xs\" fullWidth>\n            <DialogTitle>{t(`install.${variant}.title`)}</DialogTitle>\n            <DialogContent>\n                {/* pasos numerados con palabras, sin dibujar los íconos del sistema: cambian entre versiones */}\n                <Typography component=\"ol\" sx={{m: 0, pl: 3, display: 'grid', gap: 1.25}}>\n                    {steps.map((step) => (\n                        <Typography key={step} component=\"li\" variant=\"body1\">{t(`install.${variant}.${step}`)}</Typography>\n                    ))}\n                </Typography>\n            </DialogContent>\n            <DialogActions>\n                <Button variant=\"contained\" onClick={onClose}>{t('install.gotIt')}</Button>\n            </DialogActions>\n        </Dialog>\n    );\n}\n"],"names":[],"mappings":";;;;;;;;;;AAmBA,MAAM,mBAAmB,OAAO,OAAO;AAAA,EACnC,CAAC,gBAAgB,SAAS,GAAG,CAAC,SAAS,SAAS,SAAS,OAAO;AAAA,EAChE,CAAC,gBAAgB,UAAU,GAAG,CAAC,SAAS,SAAS,OAAO;AAAA,EACxD,CAAC,gBAAgB,cAAc,GAAG,CAAC,SAAS,SAAS,OAAO;AAChE,CAAC;AAQM,SAAS,uBAAuB,SAAS;AAC5C,SAAO,QAAQ,iBAAiB,OAAO,CAAC;AAC5C;AASA,SAAwB,0BAA0B,EAAC,SAAS,MAAM,SAAS,SAAQ;AAC/E,QAAM,EAAC,EAAA,IAAK,sBAAsB,UAAU,KAAK;AACjD,QAAM,QAAQ,iBAAiB,OAAO;AACtC,MAAI,CAAC,OAAO;AACR,WAAO;AAAA,EACX;AAEA,8BACK,QAAA,EAAO,MAAY,SAAkB,UAAS,MAAK,WAAS,MACzD,UAAA;AAAA,IAAA,oBAAC,aAAA,EAAa,UAAA,EAAE,WAAW,OAAO,QAAQ,GAAE;AAAA,wBAC3C,eAAA,EAEG,UAAA,oBAAC,YAAA,EAAW,WAAU,MAAK,IAAI,EAAC,GAAG,GAAG,IAAI,GAAG,SAAS,QAAQ,KAAK,QAC9D,UAAA,MAAM,IAAI,CAAC,SACR,oBAAC,YAAA,EAAsB,WAAU,MAAK,SAAQ,SAAS,UAAA,EAAE,WAAW,OAAO,IAAI,IAAI,EAAE,KAApE,IAAsE,CAC1F,GACL,GACJ;AAAA,IACA,oBAAC,eAAA,EACG,UAAA,oBAAC,QAAA,EAAO,SAAQ,aAAY,SAAS,SAAU,UAAA,EAAE,eAAe,EAAA,CAAE,EAAA,CACtE;AAAA,EAAA,GACJ;AAER;"}