@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/DataTable/useTableState.js

@@ -0,0 +1,132 @@
+"use client";
+import { useMemo, useState } from "react";
+import { parseAsString, parseAsInteger, useQueryStates, parseAsArrayOf } from "nuqs";
+const FILTER_KINDS = Object.freeze({
+  text: "text",
+  multiSelect: "multiSelect"
+});
+const SORT_SEPARATOR = ":";
+const DEFAULT_PAGE_SIZE = 25;
+function isFilterActive(kind, value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (kind === FILTER_KINDS.multiSelect) {
+    return value.length > 0;
+  }
+  return value !== "";
+}
+function parserFor(kind, defaultValue) {
+  if (kind === FILTER_KINDS.multiSelect) {
+    return parseAsArrayOf(parseAsString).withDefault(defaultValue);
+  }
+  return parseAsString.withDefault(defaultValue);
+}
+function parseSortValue(sortValue) {
+  if (!sortValue) {
+    return [];
+  }
+  const [column, direction] = sortValue.split(SORT_SEPARATOR);
+  return column ? [{ column, direction: direction === "asc" ? "asc" : "desc" }] : [];
+}
+function serializeSortOrders(sortOrders) {
+  return sortOrders.length ? `${sortOrders[0].column}${SORT_SEPARATOR}${sortOrders[0].direction}` : "";
+}
+function filtersForDatasetSwitch(filterDefaults, values) {
+  return { ...filterDefaults, ...values };
+}
+function useUrlTableState(prefix, filterDefaults, filterKinds, defaultPageSize) {
+  const parsers = useMemo(() => Object.fromEntries([
+    ...Object.entries(filterDefaults).map(([field, defaultValue]) => [field, parserFor(filterKinds[field], defaultValue)]),
+    ["sort", parseAsString.withDefault("")],
+    ["page", parseAsInteger.withDefault(0)],
+    ["pageSize", parseAsInteger.withDefault(defaultPageSize)]
+  ]), [filterDefaults, filterKinds, defaultPageSize]);
+  const [urlState, setUrlState] = useQueryStates(parsers, {
+    urlKeys: Object.fromEntries(Object.keys(parsers).map((key) => [key, `${prefix}_${key}`])),
+    // replace: filtrar no llena el historial de entradas intermedias; el Atrás del detalle regresa a la lista
+    history: "replace",
+    // lo que vale su default no se escribe en la URL
+    clearOnDefault: true
+  });
+  const filters = useMemo(
+    () => Object.fromEntries(Object.keys(filterDefaults).map((field) => [field, urlState[field]])),
+    [urlState, filterDefaults]
+  );
+  const sortOrders = useMemo(() => parseSortValue(urlState.sort), [urlState.sort]);
+  return {
+    filters,
+    sortOrders,
+    page: urlState.page,
+    pageSize: urlState.pageSize,
+    // IMPORTANTE: filtrar SIEMPRE regresa a la página 0; quedarse en la 3 de un resultado que ahora tiene una
+    // sola página deja la tabla vacía y parece que el filtro no encontró nada
+    setFilter: (field, value) => setUrlState({ [field]: value, page: 0 }),
+    // varios en UNA escritura: en dos, la tabla consultaría una vez con la mitad del cambio
+    setFilters: (values) => setUrlState({ ...values, page: 0 }),
+    clearFilter: (field) => setUrlState({ [field]: filterDefaults[field], page: 0 }),
+    clearAll: () => setUrlState({ ...filterDefaults, page: 0 }),
+    setSort: (orders) => setUrlState({ sort: serializeSortOrders(orders), page: 0 }),
+    // cambio de conjunto (otro producto): filtros, orden y página a su default en UNA escritura; el tamaño de
+    // página se respeta porque es preferencia de quien mira, no del conjunto
+    switchDataset: (values) => setUrlState({ ...filtersForDatasetSwitch(filterDefaults, values), sort: "", page: 0 }),
+    setPage: (page) => setUrlState({ page }),
+    setPageSize: (pageSize) => setUrlState({ pageSize, page: 0 })
+  };
+}
+function useLocalTableState(filterDefaults, defaultPageSize) {
+  const [filters, setFilters] = useState(filterDefaults);
+  const [sortOrders, setSortOrders] = useState([]);
+  const [page, setPage] = useState(0);
+  const [pageSize, setPageSize] = useState(defaultPageSize);
+  return {
+    filters,
+    sortOrders,
+    page,
+    pageSize,
+    setFilter: (field, value) => {
+      setFilters((currentFilters) => ({ ...currentFilters, [field]: value }));
+      setPage(0);
+    },
+    setFilters: (values) => {
+      setFilters((currentFilters) => ({ ...currentFilters, ...values }));
+      setPage(0);
+    },
+    clearFilter: (field) => {
+      setFilters((currentFilters) => ({ ...currentFilters, [field]: filterDefaults[field] }));
+      setPage(0);
+    },
+    clearAll: () => {
+      setFilters(filterDefaults);
+      setPage(0);
+    },
+    setSort: (orders) => {
+      setSortOrders(orders);
+      setPage(0);
+    },
+    switchDataset: (values) => {
+      setFilters(filtersForDatasetSwitch(filterDefaults, values));
+      setSortOrders([]);
+      setPage(0);
+    },
+    setPage,
+    setPageSize: (nextPageSize) => {
+      setPageSize(nextPageSize);
+      setPage(0);
+    }
+  };
+}
+function useTableState({ prefix, filterDefaults = {}, filterKinds = {}, defaultPageSize = DEFAULT_PAGE_SIZE }) {
+  const urlTableState = useUrlTableState(prefix ?? "table", filterDefaults, filterKinds, defaultPageSize);
+  const localTableState = useLocalTableState(filterDefaults, defaultPageSize);
+  return prefix ? urlTableState : localTableState;
+}
+export {
+  FILTER_KINDS,
+  filtersForDatasetSwitch,
+  isFilterActive,
+  parseSortValue,
+  serializeSortOrders,
+  useTableState
+};
+//# sourceMappingURL=useTableState.js.map

package/dist/DataTable/useTableState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableState.js","sources":["../../src/DataTable/useTableState.js"],"sourcesContent":["// Filtros, orden y página de una tabla. Con prefijo, la URL es la fuente de verdad (nuqs).\n//\n// Dos modos con la misma forma de salida, para que la tabla no sepa cuál está usando:\n//   con `prefix`  el estado vive en la URL: la pantalla se comparte por enlace, sobrevive a recargar y el botón\n//                 Atrás del detalle regresa a la lista tal como estaba;\n//   sin `prefix`  estado local, para tablas embebidas (un diálogo) donde reflejar filtros en la URL solo ensucia.\n//\n// El prefijo permite dos tablas en la misma pantalla sin pisarse (loads_year contra users_year). Las llaves que se\n// ven en la barra de direcciones son <prefijo>_<campo>.\n//\n// Hooks y funciones puras, no renderizan: function (regla de la casa).\nimport {useMemo, useState} from 'react';\nimport {parseAsArrayOf, parseAsInteger, parseAsString, useQueryStates} from 'nuqs';\n\nexport const FILTER_KINDS = Object.freeze({\n    text: 'text',\n    multiSelect: 'multiSelect',\n});\n\n// el orden viaja como columna:dirección, legible en la barra de direcciones\nconst SORT_SEPARATOR = ':';\n\nconst DEFAULT_PAGE_SIZE = 25;\n\n/**\n * ¿El filtro está puesto? Un texto vacío o una lista vacía no cuentan.\n *\n * @param {string|undefined} kind uno de FILTER_KINDS\n * @param {unknown} value valor del filtro\n * @returns {boolean}\n */\nexport function isFilterActive(kind, value) {\n    if (value === null || value === undefined) {\n        return false;\n    }\n    if (kind === FILTER_KINDS.multiSelect) {\n        return value.length > 0;\n    }\n    return value !== '';\n}\n\n/**\n * Parser de nuqs según el tipo de filtro.\n *\n * @param {string|undefined} kind uno de FILTER_KINDS\n * @param {unknown} defaultValue valor cuando la URL no trae el parámetro\n */\nfunction parserFor(kind, defaultValue) {\n    if (kind === FILTER_KINDS.multiSelect) {\n        return parseAsArrayOf(parseAsString).withDefault(defaultValue);\n    }\n    return parseAsString.withDefault(defaultValue);\n}\n\n/**\n * \"year:desc\" → [{column: 'year', direction: 'desc'}].\n *\n * @param {string} sortValue valor de la URL\n * @returns {Array<{column: string, direction: 'asc'|'desc'}>}\n */\nexport function parseSortValue(sortValue) {\n    if (!sortValue) {\n        return [];\n    }\n    const [column, direction] = sortValue.split(SORT_SEPARATOR);\n    return column ? [{column, direction: direction === 'asc' ? 'asc' : 'desc'}] : [];\n}\n\n/**\n * [{column: 'year', direction: 'desc'}] → \"year:desc\" ('' sin orden).\n *\n * @param {Array<{column: string, direction: 'asc'|'desc'}>} sortOrders\n * @returns {string}\n */\nexport function serializeSortOrders(sortOrders) {\n    return sortOrders.length ? `${sortOrders[0].column}${SORT_SEPARATOR}${sortOrders[0].direction}` : '';\n}\n\n/**\n * Filtros con los que arranca una tabla cuando cambia el CONJUNTO que muestra (otro producto, otra pestaña).\n *\n * Por qué existe: los filtros, el orden y la página pertenecen al conjunto que se estaba viendo. Si al cambiar de\n * producto se conservan, la tabla nueva sale filtrada por un estado o un formato que la persona eligió para el otro\n * producto y parece que \"no hay datos\". Todo vuelve a su default salvo lo que el cambio fija (p. ej. el producto).\n *\n * @param {Record<string, unknown>} filterDefaults campo → valor sin filtro\n * @param {Record<string, unknown>} values lo que fija el cambio de conjunto ({product: 'SHOES'})\n * @returns {Record<string, unknown>} todos los filtros en su default más los valores fijados\n */\nexport function filtersForDatasetSwitch(filterDefaults, values) {\n    return {...filterDefaults, ...values};\n}\n\nfunction useUrlTableState(prefix, filterDefaults, filterKinds, defaultPageSize) {\n    const parsers = useMemo(() => Object.fromEntries([\n        ...Object.entries(filterDefaults).map(([field, defaultValue]) => [field, parserFor(filterKinds[field], defaultValue)]),\n        ['sort', parseAsString.withDefault('')],\n        ['page', parseAsInteger.withDefault(0)],\n        ['pageSize', parseAsInteger.withDefault(defaultPageSize)],\n    ]), [filterDefaults, filterKinds, defaultPageSize]);\n\n    const [urlState, setUrlState] = useQueryStates(parsers, {\n        urlKeys: Object.fromEntries(Object.keys(parsers).map((key) => [key, `${prefix}_${key}`])),\n        // replace: filtrar no llena el historial de entradas intermedias; el Atrás del detalle regresa a la lista\n        history: 'replace',\n        // lo que vale su default no se escribe en la URL\n        clearOnDefault: true,\n    });\n\n    const filters = useMemo(\n        () => Object.fromEntries(Object.keys(filterDefaults).map((field) => [field, urlState[field]])),\n        [urlState, filterDefaults],\n    );\n\n    const sortOrders = useMemo(() => parseSortValue(urlState.sort), [urlState.sort]);\n\n    return {\n        filters,\n        sortOrders,\n        page: urlState.page,\n        pageSize: urlState.pageSize,\n        // IMPORTANTE: filtrar SIEMPRE regresa a la página 0; quedarse en la 3 de un resultado que ahora tiene una\n        // sola página deja la tabla vacía y parece que el filtro no encontró nada\n        setFilter: (field, value) => setUrlState({[field]: value, page: 0}),\n        // varios en UNA escritura: en dos, la tabla consultaría una vez con la mitad del cambio\n        setFilters: (values) => setUrlState({...values, page: 0}),\n        clearFilter: (field) => setUrlState({[field]: filterDefaults[field], page: 0}),\n        clearAll: () => setUrlState({...filterDefaults, page: 0}),\n        setSort: (orders) => setUrlState({sort: serializeSortOrders(orders), page: 0}),\n        // cambio de conjunto (otro producto): filtros, orden y página a su default en UNA escritura; el tamaño de\n        // página se respeta porque es preferencia de quien mira, no del conjunto\n        switchDataset: (values) => setUrlState({...filtersForDatasetSwitch(filterDefaults, values), sort: '', page: 0}),\n        setPage: (page) => setUrlState({page}),\n        setPageSize: (pageSize) => setUrlState({pageSize, page: 0}),\n    };\n}\n\nfunction useLocalTableState(filterDefaults, defaultPageSize) {\n    const [filters, setFilters] = useState(filterDefaults);\n    const [sortOrders, setSortOrders] = useState([]);\n    const [page, setPage] = useState(0);\n    const [pageSize, setPageSize] = useState(defaultPageSize);\n\n    return {\n        filters,\n        sortOrders,\n        page,\n        pageSize,\n        setFilter: (field, value) => {\n            setFilters((currentFilters) => ({...currentFilters, [field]: value}));\n            setPage(0);\n        },\n        setFilters: (values) => {\n            setFilters((currentFilters) => ({...currentFilters, ...values}));\n            setPage(0);\n        },\n        clearFilter: (field) => {\n            setFilters((currentFilters) => ({...currentFilters, [field]: filterDefaults[field]}));\n            setPage(0);\n        },\n        clearAll: () => {\n            setFilters(filterDefaults);\n            setPage(0);\n        },\n        setSort: (orders) => {\n            setSortOrders(orders);\n            setPage(0);\n        },\n        switchDataset: (values) => {\n            setFilters(filtersForDatasetSwitch(filterDefaults, values));\n            setSortOrders([]);\n            setPage(0);\n        },\n        setPage,\n        setPageSize: (nextPageSize) => {\n            setPageSize(nextPageSize);\n            setPage(0);\n        },\n    };\n}\n\n/**\n * Estado de una tabla de servidor.\n *\n * OJO: filterDefaults y filterKinds se pasan como constantes de módulo (fuera del componente). Un objeto nuevo en\n * cada render arma parsers nuevos en cada render.\n *\n * @param {object} options\n * @param {string} [options.prefix] con prefijo, en la URL; sin él, en memoria\n * @param {Record<string, unknown>} [options.filterDefaults] campo → valor sin filtro ('' o [])\n * @param {Record<string, string>} [options.filterKinds] campo → FILTER_KINDS\n * @param {number} [options.defaultPageSize]\n */\nexport function useTableState({prefix, filterDefaults = {}, filterKinds = {}, defaultPageSize = DEFAULT_PAGE_SIZE}) {\n    // los dos hooks se llaman SIEMPRE (regla de los hooks); el que no aplica no se usa\n    const urlTableState = useUrlTableState(prefix ?? 'table', filterDefaults, filterKinds, defaultPageSize);\n    const localTableState = useLocalTableState(filterDefaults, defaultPageSize);\n    return prefix ? urlTableState : localTableState;\n}\n"],"names":[],"mappings":"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"}

package/dist/access/Can.js

@@ -0,0 +1,9 @@
+"use client";
+import { useCan } from "./useCan.js";
+function Can({ access, children, fallback = null }) {
+  return useCan(access) ? children : fallback;
+}
+export {
+  Can as default
+};
+//# sourceMappingURL=Can.js.map

package/dist/access/Can.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Can.js","sources":["../../src/access/Can.jsx"],"sourcesContent":["// Pinta lo de adentro solo si la sesión puede (la misma regla del menú y las rutas):\n//\n//   <Can access={{ability: 'orders.cancel'}}><Button>Cancelar pedido</Button></Can>\n//\n// Lo que no se puede, no se ve (fallback, si se quiere enseñar otra cosa). El backend vuelve a revisar cada petición.\n//\n// Genérico del paquete: function (regla de la casa).\nimport {useCan} from '@/access/useCan.js';\n\n/**\n * @param {object} props\n * @param {object} props.access la regla (accessRules.js)\n * @param {import('react').ReactNode} props.children\n * @param {import('react').ReactNode} [props.fallback] lo que se pinta si no puede; por omisión nada\n */\nexport default function Can({access, children, fallback = null}) {\n    return useCan(access) ? children : fallback;\n}\n"],"names":[],"mappings":";;AAeA,SAAwB,IAAI,EAAC,QAAQ,UAAU,WAAW,QAAO;AAC7D,SAAO,OAAO,MAAM,IAAI,WAAW;AACvC;"}

package/dist/access/PermissionMatrix.js

@@ -0,0 +1,84 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useId } from "react";
+import { useToolkitTranslation } from "../toolkit/useToolkitTranslation.js";
+import Box from "@mui/material/Box";
+import Checkbox from "@mui/material/Checkbox";
+import Chip from "@mui/material/Chip";
+import FormControlLabel from "@mui/material/FormControlLabel";
+import Paper from "@mui/material/Paper";
+import Stack from "@mui/material/Stack";
+import Typography from "@mui/material/Typography";
+import { groupStateOf, withPermissionGroup, withPermission } from "./permissionGroups.js";
+import ComponentTexts from "../toolkit/ComponentTexts.js";
+function PermissionOption({ permission, isGranted, readOnly, onToggle }) {
+  return /* @__PURE__ */ jsx(
+    FormControlLabel,
+    {
+      sx: { alignItems: "flex-start", m: 0, gap: 0.5 },
+      control: /* @__PURE__ */ jsx(
+        Checkbox,
+        {
+          size: "small",
+          checked: isGranted,
+          disabled: readOnly,
+          onChange: (event) => onToggle(event.target.checked),
+          slotProps: { input: { "data-permission": permission.key } },
+          sx: { mt: -0.5 }
+        }
+      ),
+      label: /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "body2", children: permission.label }),
+        permission.description && /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "text.secondary", component: "p", children: permission.description })
+      ] })
+    }
+  );
+}
+function PermissionGroup({ group, value, onChange, isReadOnly }) {
+  const { t } = useToolkitTranslation("access");
+  const titleId = useId();
+  const state = groupStateOf(group, value);
+  return /* @__PURE__ */ jsxs(Paper, { variant: "outlined", role: "group", "aria-labelledby": titleId, "data-group": group.key, sx: { overflow: "hidden" }, children: [
+    /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, sx: { alignItems: "center", px: 1.5, py: 0.75, borderBottom: 1, borderColor: "divider", bgcolor: "action.hover" }, children: [
+      /* @__PURE__ */ jsx(
+        Checkbox,
+        {
+          size: "small",
+          checked: state.isAll,
+          indeterminate: state.isSome,
+          disabled: isReadOnly || state.total === 0,
+          onChange: (event) => onChange(withPermissionGroup(value, group, event.target.checked)),
+          slotProps: { input: { "aria-label": t("permissions.allOf", { group: group.label }) } }
+        }
+      ),
+      /* @__PURE__ */ jsx(Typography, { id: titleId, variant: "subtitle2", component: "h3", sx: { flexGrow: 1 }, children: group.label }),
+      /* @__PURE__ */ jsx(
+        Chip,
+        {
+          size: "small",
+          label: t("permissions.countOf", { count: state.grantedCount, total: state.total }),
+          color: state.grantedCount > 0 ? "primary" : "default",
+          variant: state.isAll ? "filled" : "outlined"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { sx: { display: "grid", gridTemplateColumns: { xs: "1fr", md: "repeat(2, minmax(0, 1fr))" }, gap: 1.5, p: 2 }, children: group.permissions.map((permission) => /* @__PURE__ */ jsx(
+      PermissionOption,
+      {
+        permission,
+        isGranted: value.includes(permission.key),
+        readOnly: isReadOnly,
+        onToggle: (isGranted) => onChange(withPermission(value, permission.key, isGranted))
+      },
+      permission.key
+    )) })
+  ] });
+}
+function PermissionMatrix({ groups, value, onChange, readOnly = false, texts }) {
+  const isReadOnly = readOnly || !onChange;
+  return /* @__PURE__ */ jsx(ComponentTexts, { namespace: "access", texts, children: /* @__PURE__ */ jsx(Stack, { spacing: 1.5, children: groups.map((group) => /* @__PURE__ */ jsx(PermissionGroup, { group, value, onChange, isReadOnly }, group.key)) }) });
+}
+export {
+  PermissionMatrix as default
+};
+//# sourceMappingURL=PermissionMatrix.js.map

package/dist/access/PermissionMatrix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionMatrix.js","sources":["../../src/access/PermissionMatrix.jsx"],"sourcesContent":["// Los permisos de un perfil, agrupados (un grupo por módulo), para la pantalla de «Perfiles y permisos»: cada grupo con\n// su casilla de «todos» (a medias si tiene algunos) y cuántos tiene, y cada permiso con su nombre y, si hace falta, qué\n// deja hacer en palabras normales.\n//\n//   <PermissionMatrix groups={PERMISSION_GROUPS} value={profile.abilities} onChange={setAbilities} />\n//\n// Los permisos son los mismos textos que piden los menu.js y las rutas (access: {ability: 'orders.view'}), así que lo que\n// se palomea aquí es lo que el menú enseña o esconde. La lista de grupos la arma el proyecto (RBAC propio); guardar es\n// cosa de la pantalla.\n//\n// Genérico del paquete: function (regla de la casa). No sabe de negocio: todo llega ya traducido.\nimport {useId} from 'react';\nimport {useToolkitTranslation} from '@/toolkit/useToolkitTranslation.js';\nimport Box from '@mui/material/Box';\nimport Checkbox from '@mui/material/Checkbox';\nimport Chip from '@mui/material/Chip';\nimport FormControlLabel from '@mui/material/FormControlLabel';\nimport Paper from '@mui/material/Paper';\nimport Stack from '@mui/material/Stack';\nimport Typography from '@mui/material/Typography';\n\nimport {groupStateOf, withPermission, withPermissionGroup} from '@/access/permissionGroups.js';\nimport ComponentTexts from '@/toolkit/ComponentTexts.jsx';\n\n/**\n * Un permiso: su casilla, su nombre y qué deja hacer.\n *\n * @param {{permission: {key: string, label: string, description?: string}, isGranted: boolean, readOnly: boolean, onToggle: (isGranted: boolean) => void}} props\n */\nfunction PermissionOption({permission, isGranted, readOnly, onToggle}) {\n    return (\n        <FormControlLabel\n            sx={{alignItems: 'flex-start', m: 0, gap: 0.5}}\n            control={<Checkbox size=\"small\" checked={isGranted} disabled={readOnly} onChange={(event) => onToggle(event.target.checked)}\n                               slotProps={{input: {'data-permission': permission.key}}} sx={{mt: -0.5}} />}\n            label={(\n                <Box>\n                    <Typography variant=\"body2\">{permission.label}</Typography>\n                    {permission.description && <Typography variant=\"caption\" color=\"text.secondary\" component=\"p\">{permission.description}</Typography>}\n                </Box>\n            )}\n        />\n    );\n}\n\n/**\n * Un grupo: su encabezado con «todos» y cuántos tiene, y sus permisos.\n *\n * OJO: es un grupo con role=\"group\" y no un <fieldset>: el navegador pinta el <legend> encima del borde y dejaba una franja\n * blanca arriba del encabezado.\n *\n * @param {{group: object, value: string[], onChange: Function, isReadOnly: boolean}} props\n */\nfunction PermissionGroup({group, value, onChange, isReadOnly}) {\n    const {t} = useToolkitTranslation('access');\n    const titleId = useId();\n    const state = groupStateOf(group, value);\n    return (\n        <Paper variant=\"outlined\" role=\"group\" aria-labelledby={titleId} data-group={group.key} sx={{overflow: 'hidden'}}>\n            <Stack direction=\"row\" spacing={1} sx={{alignItems: 'center', px: 1.5, py: 0.75, borderBottom: 1, borderColor: 'divider', bgcolor: 'action.hover'}}>\n                <Checkbox size=\"small\" checked={state.isAll} indeterminate={state.isSome} disabled={isReadOnly || state.total === 0}\n                          onChange={(event) => onChange(withPermissionGroup(value, group, event.target.checked))}\n                          slotProps={{input: {'aria-label': t('permissions.allOf', {group: group.label})}}} />\n                <Typography id={titleId} variant=\"subtitle2\" component=\"h3\" sx={{flexGrow: 1}}>{group.label}</Typography>\n                <Chip size=\"small\" label={t('permissions.countOf', {count: state.grantedCount, total: state.total})}\n                      color={state.grantedCount > 0 ? 'primary' : 'default'} variant={state.isAll ? 'filled' : 'outlined'} />\n            </Stack>\n            <Box sx={{display: 'grid', gridTemplateColumns: {xs: '1fr', md: 'repeat(2, minmax(0, 1fr))'}, gap: 1.5, p: 2}}>\n                {group.permissions.map((permission) => (\n                    <PermissionOption key={permission.key} permission={permission} isGranted={value.includes(permission.key)} readOnly={isReadOnly}\n                                      onToggle={(isGranted) => onChange(withPermission(value, permission.key, isGranted))} />\n                ))}\n            </Box>\n        </Paper>\n    );\n}\n\n/**\n * @param {object} props\n * @param {Array<{key: string, label: string, permissions: Array<{key: string, label: string, description?: string}>}>} props.groups\n * @param {string[]} props.value los permisos del perfil\n * @param {(value: string[]) => void} [props.onChange] sin ella, o con readOnly, solo se ven\n * @param {boolean} [props.readOnly] un perfil que no se puede cambiar (el de administración)\n * @param {object} [props.texts] los textos que cambian, con la forma de `access` en los textos del paquete\n */\nexport default function PermissionMatrix({groups, value, onChange, readOnly = false, texts}) {\n    const isReadOnly = readOnly || !onChange;\n    return (\n        <ComponentTexts namespace=\"access\" texts={texts}>\n            <Stack spacing={1.5}>\n                {groups.map((group) => <PermissionGroup key={group.key} group={group} value={value} onChange={onChange} isReadOnly={isReadOnly} />)}\n            </Stack>\n        </ComponentTexts>\n    );\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;AA6BA,SAAS,iBAAiB,EAAC,YAAY,WAAW,UAAU,YAAW;AACnE,SACI;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,IAAI,EAAC,YAAY,cAAc,GAAG,GAAG,KAAK,IAAA;AAAA,MAC1C,SAAS;AAAA,QAAC;AAAA,QAAA;AAAA,UAAS,MAAK;AAAA,UAAQ,SAAS;AAAA,UAAW,UAAU;AAAA,UAAU,UAAU,CAAC,UAAU,SAAS,MAAM,OAAO,OAAO;AAAA,UACvG,WAAW,EAAC,OAAO,EAAC,mBAAmB,WAAW,MAAG;AAAA,UAAI,IAAI,EAAC,IAAI,KAAA;AAAA,QAAI;AAAA,MAAA;AAAA,MACzF,4BACK,KAAA,EACG,UAAA;AAAA,QAAA,oBAAC,YAAA,EAAW,SAAQ,SAAS,UAAA,WAAW,OAAM;AAAA,QAC7C,WAAW,eAAe,oBAAC,YAAA,EAAW,SAAQ,WAAU,OAAM,kBAAiB,WAAU,KAAK,UAAA,WAAW,YAAA,CAAY;AAAA,MAAA,EAAA,CAC1H;AAAA,IAAA;AAAA,EAAA;AAIhB;AAUA,SAAS,gBAAgB,EAAC,OAAO,OAAO,UAAU,cAAa;AAC3D,QAAM,EAAC,EAAA,IAAK,sBAAsB,QAAQ;AAC1C,QAAM,UAAU,MAAA;AAChB,QAAM,QAAQ,aAAa,OAAO,KAAK;AACvC,SACI,qBAAC,OAAA,EAAM,SAAQ,YAAW,MAAK,SAAQ,mBAAiB,SAAS,cAAY,MAAM,KAAK,IAAI,EAAC,UAAU,YACnG,UAAA;AAAA,IAAA,qBAAC,SAAM,WAAU,OAAM,SAAS,GAAG,IAAI,EAAC,YAAY,UAAU,IAAI,KAAK,IAAI,MAAM,cAAc,GAAG,aAAa,WAAW,SAAS,kBAC/H,UAAA;AAAA,MAAA;AAAA,QAAC;AAAA,QAAA;AAAA,UAAS,MAAK;AAAA,UAAQ,SAAS,MAAM;AAAA,UAAO,eAAe,MAAM;AAAA,UAAQ,UAAU,cAAc,MAAM,UAAU;AAAA,UACxG,UAAU,CAAC,UAAU,SAAS,oBAAoB,OAAO,OAAO,MAAM,OAAO,OAAO,CAAC;AAAA,UACrF,WAAW,EAAC,OAAO,EAAC,cAAc,EAAE,qBAAqB,EAAC,OAAO,MAAM,MAAA,CAAM,IAAC;AAAA,QAAC;AAAA,MAAA;AAAA,MACzF,oBAAC,YAAA,EAAW,IAAI,SAAS,SAAQ,aAAY,WAAU,MAAK,IAAI,EAAC,UAAU,EAAA,GAAK,gBAAM,OAAM;AAAA,MAC5F;AAAA,QAAC;AAAA,QAAA;AAAA,UAAK,MAAK;AAAA,UAAQ,OAAO,EAAE,uBAAuB,EAAC,OAAO,MAAM,cAAc,OAAO,MAAM,OAAM;AAAA,UAC5F,OAAO,MAAM,eAAe,IAAI,YAAY;AAAA,UAAW,SAAS,MAAM,QAAQ,WAAW;AAAA,QAAA;AAAA,MAAA;AAAA,IAAY,GAC/G;AAAA,IACA,oBAAC,OAAI,IAAI,EAAC,SAAS,QAAQ,qBAAqB,EAAC,IAAI,OAAO,IAAI,+BAA8B,KAAK,KAAK,GAAG,KACtG,UAAA,MAAM,YAAY,IAAI,CAAC,eACpB;AAAA,MAAC;AAAA,MAAA;AAAA,QAAsC;AAAA,QAAwB,WAAW,MAAM,SAAS,WAAW,GAAG;AAAA,QAAG,UAAU;AAAA,QAClG,UAAU,CAAC,cAAc,SAAS,eAAe,OAAO,WAAW,KAAK,SAAS,CAAC;AAAA,MAAA;AAAA,MAD7E,WAAW;AAAA,IAAA,CAErC,EAAA,CACL;AAAA,EAAA,GACJ;AAER;AAUA,SAAwB,iBAAiB,EAAC,QAAQ,OAAO,UAAU,WAAW,OAAO,SAAQ;AACzF,QAAM,aAAa,YAAY,CAAC;AAChC,SACI,oBAAC,kBAAe,WAAU,UAAS,OAC/B,UAAA,oBAAC,OAAA,EAAM,SAAS,KACX,UAAA,OAAO,IAAI,CAAC,UAAU,oBAAC,iBAAA,EAAgC,OAAc,OAAc,UAAoB,cAA3D,MAAM,GAA6E,CAAE,EAAA,CACtI,EAAA,CACJ;AAER;"}

package/dist/access/RequireAccess.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCan } from "./useCan.js";
+import ErrorPage, { ERROR_PAGE_KIND } from "../ui/layout/ErrorPage.js";
+function RequireAccess({ access, children, fallback }) {
+  if (useCan(access)) {
+    return children;
+  }
+  return fallback ?? /* @__PURE__ */ jsx(ErrorPage, { kind: ERROR_PAGE_KIND.forbidden });
+}
+export {
+  RequireAccess as default
+};
+//# sourceMappingURL=RequireAccess.js.map

package/dist/access/RequireAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequireAccess.js","sources":["../../src/access/RequireAccess.jsx"],"sourcesContent":["// Una pantalla (o un grupo de pantallas) que solo se ve con permiso, con la misma regla de su menu.js: quien no puede ve\n// la página de «sin permiso» (403) en lugar de una pantalla vacía que truena al pedir sus datos.\n//\n//   <RequireAccess access={{ability: 'users.admin'}}><UsersPage /></RequireAccess>\n//\n// Con react-router, withAccess (@stackcraftmx/calcita/react-router) envuelve un grupo de rutas con esto.\n//\n// Genérico del paquete: function (regla de la casa).\nimport {useCan} from '@/access/useCan.js';\nimport ErrorPage, {ERROR_PAGE_KIND} from '@/ui/layout/ErrorPage.jsx';\n\n/**\n * @param {object} props\n * @param {object} [props.access] la regla (accessRules.js); sin ella se ve\n * @param {import('react').ReactNode} props.children\n * @param {import('react').ReactNode} [props.fallback] lo que se ve sin permiso; por omisión la página de 403\n */\nexport default function RequireAccess({access, children, fallback}) {\n    if (useCan(access)) {\n        return children;\n    }\n    return fallback ?? <ErrorPage kind={ERROR_PAGE_KIND.forbidden} />;\n}\n"],"names":[],"mappings":";;;;AAiBA,SAAwB,cAAc,EAAC,QAAQ,UAAU,YAAW;AAChE,MAAI,OAAO,MAAM,GAAG;AAChB,WAAO;AAAA,EACX;AACA,SAAO,YAAY,oBAAC,WAAA,EAAU,MAAM,gBAAgB,WAAW;AACnE;"}

package/dist/access/accessRules.js

@@ -0,0 +1,49 @@
+function allowOnlyUnrestricted(access) {
+  return !access;
+}
+function createAccessChecker({ abilities = [], roles = [], policies = {}, context = {} } = {}) {
+  const abilitySet = new Set(abilities);
+  const roleSet = new Set(roles);
+  const passesPolicy = (policyName) => {
+    const policy = policies[policyName];
+    if (typeof policy !== "function") {
+      throw new Error(`La política «${policyName}» no está definida en createAccessChecker({policies})`);
+    }
+    return Boolean(policy(context));
+  };
+  return (access) => {
+    if (!access) {
+      return true;
+    }
+    if (access.ability && !abilitySet.has(access.ability)) {
+      return false;
+    }
+    if (access.anyOf && !access.anyOf.some((ability) => abilitySet.has(ability))) {
+      return false;
+    }
+    if (access.allOf && !access.allOf.every((ability) => abilitySet.has(ability))) {
+      return false;
+    }
+    if (access.role && !roleSet.has(access.role)) {
+      return false;
+    }
+    if (access.anyRole && !access.anyRole.some((role) => roleSet.has(role))) {
+      return false;
+    }
+    if (access.policy && !passesPolicy(access.policy)) {
+      return false;
+    }
+    if (access.policies && !access.policies.every(passesPolicy)) {
+      return false;
+    }
+    if (access.check && !access.check(context)) {
+      return false;
+    }
+    return true;
+  };
+}
+export {
+  allowOnlyUnrestricted,
+  createAccessChecker
+};
+//# sourceMappingURL=accessRules.js.map

package/dist/access/accessRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessRules.js","sources":["../../src/access/accessRules.js"],"sourcesContent":["// Quién puede ver qué: el menú, las rutas y los botones preguntan lo mismo con la misma regla («access»).\n//\n// El framework NO sabe de roles ni de permisos: cada proyecto declara sus reglas como le acomode y le da a ToolkitProvider\n// una función canAccess(access) → boolean. Para no programarla cada vez, createAccessChecker la arma con las formas de\n// siempre, y se pueden combinar (todas las que vengan tienen que cumplirse):\n//\n//   RBAC por permisos (las `abilities` que manda la sesión):\n//     {ability: 'orders.view'}                  ese permiso\n//     {anyOf: ['orders.view', 'orders.admin']}  alguno de esos\n//     {allOf: ['orders.view', 'reports.view']}  todos\n//   RBAC por roles:\n//     {role: 'admin'}  ·  {anyRole: ['admin', 'supervisor']}\n//   ABAC (atributos: dueño del registro, organización, horario…):\n//     {policy: 'ownsRecord'}  ·  {policies: ['ownsRecord', 'sameOrganization']}   políticas con nombre, que el proyecto\n//                                                                                  define una vez en createAccessChecker\n//     {check: (context) => context.user.id === record.ownerId}                    la regla escrita ahí mismo\n//\n// Sin access (undefined) lo ve cualquiera con sesión. Sin sesión o sin la lista, nada: falla CERRADO.\n//\n// OJO: esto solo decide lo que se PINTA. Lo que cada quien puede hacer lo vuelve a decidir el backend en cada petición;\n// cambiar esto en el navegador no abre nada.\n//\n// Funciones puras, sin React: function (regla de la casa). Se prueban con node --test (accessRules.test.js).\n\n/**\n * El canAccess de un proyecto que no usa permisos: sin access lo ve cualquiera; con access, nadie (falla cerrado, para\n * que una regla escrita y sin conectar se note en lugar de abrir todo).\n *\n * @param {object|undefined|null} access\n * @returns {boolean}\n */\nexport function allowOnlyUnrestricted(access) {\n    return !access;\n}\n\n/**\n * Arma el canAccess(access) del proyecto con sus permisos, sus roles y sus políticas.\n *\n * @param {object} [options]\n * @param {string[]} [options.abilities] los permisos de la sesión (p. ej. los `abilities` que manda el backend)\n * @param {string[]} [options.roles] los roles de la sesión\n * @param {Record<string, (context: any) => boolean>} [options.policies] las políticas con nombre (ABAC); reciben el context\n * @param {object} [options.context] lo que reciben las políticas y los check (la persona, su organización…)\n * @returns {(access: object|undefined|null) => boolean}\n */\nexport function createAccessChecker({abilities = [], roles = [], policies = {}, context = {}} = {}) {\n    const abilitySet = new Set(abilities);\n    const roleSet = new Set(roles);\n\n    const passesPolicy = (policyName) => {\n        const policy = policies[policyName];\n        // una política que nadie definió es un error de configuración: truena en vez de abrir o cerrar en silencio\n        if (typeof policy !== 'function') {\n            throw new Error(`La política «${policyName}» no está definida en createAccessChecker({policies})`);\n        }\n        return Boolean(policy(context));\n    };\n\n    return (access) => {\n        if (!access) {\n            return true;\n        }\n        if (access.ability && !abilitySet.has(access.ability)) {\n            return false;\n        }\n        if (access.anyOf && !access.anyOf.some((ability) => abilitySet.has(ability))) {\n            return false;\n        }\n        if (access.allOf && !access.allOf.every((ability) => abilitySet.has(ability))) {\n            return false;\n        }\n        if (access.role && !roleSet.has(access.role)) {\n            return false;\n        }\n        if (access.anyRole && !access.anyRole.some((role) => roleSet.has(role))) {\n            return false;\n        }\n        if (access.policy && !passesPolicy(access.policy)) {\n            return false;\n        }\n        if (access.policies && !access.policies.every(passesPolicy)) {\n            return false;\n        }\n        if (access.check && !access.check(context)) {\n            return false;\n        }\n        return true;\n    };\n}\n"],"names":[],"mappings":"AA+BO,SAAS,sBAAsB,QAAQ;AAC1C,SAAO,CAAC;AACZ;AAYO,SAAS,oBAAoB,EAAC,YAAY,CAAA,GAAI,QAAQ,CAAA,GAAI,WAAW,IAAI,UAAU,CAAA,EAAE,IAAI,CAAA,GAAI;AAChG,QAAM,aAAa,IAAI,IAAI,SAAS;AACpC,QAAM,UAAU,IAAI,IAAI,KAAK;AAE7B,QAAM,eAAe,CAAC,eAAe;AACjC,UAAM,SAAS,SAAS,UAAU;AAElC,QAAI,OAAO,WAAW,YAAY;AAC9B,YAAM,IAAI,MAAM,gBAAgB,UAAU,uDAAuD;AAAA,IACrG;AACA,WAAO,QAAQ,OAAO,OAAO,CAAC;AAAA,EAClC;AAEA,SAAO,CAAC,WAAW;AACf,QAAI,CAAC,QAAQ;AACT,aAAO;AAAA,IACX;AACA,QAAI,OAAO,WAAW,CAAC,WAAW,IAAI,OAAO,OAAO,GAAG;AACnD,aAAO;AAAA,IACX;AACA,QAAI,OAAO,SAAS,CAAC,OAAO,MAAM,KAAK,CAAC,YAAY,WAAW,IAAI,OAAO,CAAC,GAAG;AAC1E,aAAO;AAAA,IACX;AACA,QAAI,OAAO,SAAS,CAAC,OAAO,MAAM,MAAM,CAAC,YAAY,WAAW,IAAI,OAAO,CAAC,GAAG;AAC3E,aAAO;AAAA,IACX;AACA,QAAI,OAAO,QAAQ,CAAC,QAAQ,IAAI,OAAO,IAAI,GAAG;AAC1C,aAAO;AAAA,IACX;AACA,QAAI,OAAO,WAAW,CAAC,OAAO,QAAQ,KAAK,CAAC,SAAS,QAAQ,IAAI,IAAI,CAAC,GAAG;AACrE,aAAO;AAAA,IACX;AACA,QAAI,OAAO,UAAU,CAAC,aAAa,OAAO,MAAM,GAAG;AAC/C,aAAO;AAAA,IACX;AACA,QAAI,OAAO,YAAY,CAAC,OAAO,SAAS,MAAM,YAAY,GAAG;AACzD,aAAO;AAAA,IACX;AACA,QAAI,OAAO,SAAS,CAAC,OAAO,MAAM,OAAO,GAAG;AACxC,aAAO;AAAA,IACX;AACA,WAAO;AAAA,EACX;AACJ;"}

package/dist/access/permissionGroups.js

@@ -0,0 +1,43 @@
+const LAST_ORDER = 1e3;
+function composePermissionGroups(menuModules, t) {
+  const modules = Array.isArray(menuModules) ? menuModules : Object.values(menuModules);
+  return modules.filter((menuModule) => Array.isArray(menuModule.permissions) && menuModule.permissions.length > 0).sort((first, second) => (first.order ?? LAST_ORDER) - (second.order ?? LAST_ORDER)).map((menuModule) => {
+    const menuItem = menuModule.buildMenuItem?.({}) ?? {};
+    return {
+      key: menuItem.to ?? menuModule.permissions[0].key,
+      label: menuItem.label ?? t(menuItem.labelKey),
+      permissions: menuModule.permissions.map((permission) => ({
+        key: permission.key,
+        label: permission.label ?? t(permission.labelKey),
+        description: permission.description ?? (permission.descriptionKey ? t(permission.descriptionKey) : void 0)
+      }))
+    };
+  });
+}
+function groupStateOf(group, granted) {
+  const grantedSet = new Set(granted);
+  const grantedCount = group.permissions.filter((permission) => grantedSet.has(permission.key)).length;
+  const total = group.permissions.length;
+  return { grantedCount, total, isAll: total > 0 && grantedCount === total, isSome: grantedCount > 0 && grantedCount < total };
+}
+function withPermission(granted, permissionKey, shouldGrant) {
+  if (shouldGrant) {
+    return granted.includes(permissionKey) ? [...granted] : [...granted, permissionKey];
+  }
+  return granted.filter((key) => key !== permissionKey);
+}
+function withPermissionGroup(granted, group, shouldGrant) {
+  const groupKeys = new Set(group.permissions.map((permission) => permission.key));
+  if (shouldGrant) {
+    const missing = group.permissions.map((permission) => permission.key).filter((key) => !granted.includes(key));
+    return [...granted, ...missing];
+  }
+  return granted.filter((key) => !groupKeys.has(key));
+}
+export {
+  composePermissionGroups,
+  groupStateOf,
+  withPermission,
+  withPermissionGroup
+};
+//# sourceMappingURL=permissionGroups.js.map

package/dist/access/permissionGroups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionGroups.js","sources":["../../src/access/permissionGroups.js"],"sourcesContent":["// La lógica de la pantalla de perfiles y permisos (PermissionMatrix), sin React: cuántos permisos de un grupo tiene un\n// perfil, y prender o apagar un permiso o un grupo entero.\n//\n// Los permisos son los mismos textos que piden los menu.js y las rutas (access: {ability: 'orders.view'}). Cada módulo\n// declara los suyos en su menu.js y composePermissionGroups los junta (un grupo por módulo, en el orden del menú): la\n// pantalla de perfiles no tiene lista central que editar. Guardar la lista de permisos del perfil es cosa del backend.\n//\n//   // modules/orders/menu.js\n//   export const permissions = [\n//       {key: 'orders.view', labelKey: 'orders:permissions.view', descriptionKey: 'orders:permissions.viewDescription'},\n//       {key: 'orders.cancel', labelKey: 'orders:permissions.cancel'},\n//   ];\n//\n// Funciones puras, sin React: function (regla de la casa). Se prueban con node --test (permissionGroups.test.js).\n\n// la posición de un módulo que no dice su order: al final (la misma regla que composeMenu)\nconst LAST_ORDER = 1000;\n\n/**\n * Los grupos de permisos que declaran los módulos en su menu.js (`export const permissions`), uno por módulo y en el orden\n * del menú, con el nombre de su entrada del menú como título del grupo.\n *\n * @param {Record<string, any>|any[]} menuModules lo que regresa import.meta.glob(..., {eager: true}) o una lista\n * @param {(key: string, values?: object) => string} t el traductor (para las llaves labelKey y descriptionKey)\n * @returns {Array<{key: string, label: string, permissions: Array<{key: string, label: string, description?: string}>}>}\n */\nexport function composePermissionGroups(menuModules, t) {\n    const modules = Array.isArray(menuModules) ? menuModules : Object.values(menuModules);\n    return modules\n        .filter((menuModule) => Array.isArray(menuModule.permissions) && menuModule.permissions.length > 0)\n        .sort((first, second) => (first.order ?? LAST_ORDER) - (second.order ?? LAST_ORDER))\n        .map((menuModule) => {\n            const menuItem = menuModule.buildMenuItem?.({}) ?? {};\n            return {\n                key: menuItem.to ?? menuModule.permissions[0].key,\n                label: menuItem.label ?? t(menuItem.labelKey),\n                permissions: menuModule.permissions.map((permission) => ({\n                    key: permission.key,\n                    label: permission.label ?? t(permission.labelKey),\n                    description: permission.description ?? (permission.descriptionKey ? t(permission.descriptionKey) : undefined),\n                })),\n            };\n        });\n}\n\n/**\n * Cuántos permisos del grupo están dados.\n *\n * @param {{permissions: Array<{key: string}>}} group\n * @param {string[]} granted los permisos del perfil\n * @returns {{grantedCount: number, total: number, isAll: boolean, isSome: boolean}}\n */\nexport function groupStateOf(group, granted) {\n    const grantedSet = new Set(granted);\n    const grantedCount = group.permissions.filter((permission) => grantedSet.has(permission.key)).length;\n    const total = group.permissions.length;\n    return {grantedCount, total, isAll: total > 0 && grantedCount === total, isSome: grantedCount > 0 && grantedCount < total};\n}\n\n/**\n * Prende o apaga un permiso. Lo demás se queda en su orden; uno nuevo va al final.\n *\n * @param {string[]} granted\n * @param {string} permissionKey\n * @param {boolean} shouldGrant\n * @returns {string[]} la lista nueva (no cambia la de entrada)\n */\nexport function withPermission(granted, permissionKey, shouldGrant) {\n    if (shouldGrant) {\n        return granted.includes(permissionKey) ? [...granted] : [...granted, permissionKey];\n    }\n    return granted.filter((key) => key !== permissionKey);\n}\n\n/**\n * Prende o apaga todos los permisos de un grupo. Los que ya estaban se quedan en su lugar; los que faltan van al final.\n *\n * @param {string[]} granted\n * @param {{permissions: Array<{key: string}>}} group\n * @param {boolean} shouldGrant\n * @returns {string[]}\n */\nexport function withPermissionGroup(granted, group, shouldGrant) {\n    const groupKeys = new Set(group.permissions.map((permission) => permission.key));\n    if (shouldGrant) {\n        const missing = group.permissions.map((permission) => permission.key).filter((key) => !granted.includes(key));\n        return [...granted, ...missing];\n    }\n    return granted.filter((key) => !groupKeys.has(key));\n}\n"],"names":[],"mappings":"AAgBA,MAAM,aAAa;AAUZ,SAAS,wBAAwB,aAAa,GAAG;AACpD,QAAM,UAAU,MAAM,QAAQ,WAAW,IAAI,cAAc,OAAO,OAAO,WAAW;AACpF,SAAO,QACF,OAAO,CAAC,eAAe,MAAM,QAAQ,WAAW,WAAW,KAAK,WAAW,YAAY,SAAS,CAAC,EACjG,KAAK,CAAC,OAAO,YAAY,MAAM,SAAS,eAAe,OAAO,SAAS,WAAW,EAClF,IAAI,CAAC,eAAe;AACjB,UAAM,WAAW,WAAW,gBAAgB,CAAA,CAAE,KAAK,CAAA;AACnD,WAAO;AAAA,MACH,KAAK,SAAS,MAAM,WAAW,YAAY,CAAC,EAAE;AAAA,MAC9C,OAAO,SAAS,SAAS,EAAE,SAAS,QAAQ;AAAA,MAC5C,aAAa,WAAW,YAAY,IAAI,CAAC,gBAAgB;AAAA,QACrD,KAAK,WAAW;AAAA,QAChB,OAAO,WAAW,SAAS,EAAE,WAAW,QAAQ;AAAA,QAChD,aAAa,WAAW,gBAAgB,WAAW,iBAAiB,EAAE,WAAW,cAAc,IAAI;AAAA,MACvH,EAAkB;AAAA,IAClB;AAAA,EACQ,CAAC;AACT;AASO,SAAS,aAAa,OAAO,SAAS;AACzC,QAAM,aAAa,IAAI,IAAI,OAAO;AAClC,QAAM,eAAe,MAAM,YAAY,OAAO,CAAC,eAAe,WAAW,IAAI,WAAW,GAAG,CAAC,EAAE;AAC9F,QAAM,QAAQ,MAAM,YAAY;AAChC,SAAO,EAAC,cAAc,OAAO,OAAO,QAAQ,KAAK,iBAAiB,OAAO,QAAQ,eAAe,KAAK,eAAe,MAAK;AAC7H;AAUO,SAAS,eAAe,SAAS,eAAe,aAAa;AAChE,MAAI,aAAa;AACb,WAAO,QAAQ,SAAS,aAAa,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,SAAS,aAAa;AAAA,EACtF;AACA,SAAO,QAAQ,OAAO,CAAC,QAAQ,QAAQ,aAAa;AACxD;AAUO,SAAS,oBAAoB,SAAS,OAAO,aAAa;AAC7D,QAAM,YAAY,IAAI,IAAI,MAAM,YAAY,IAAI,CAAC,eAAe,WAAW,GAAG,CAAC;AAC/E,MAAI,aAAa;AACb,UAAM,UAAU,MAAM,YAAY,IAAI,CAAC,eAAe,WAAW,GAAG,EAAE,OAAO,CAAC,QAAQ,CAAC,QAAQ,SAAS,GAAG,CAAC;AAC5G,WAAO,CAAC,GAAG,SAAS,GAAG,OAAO;AAAA,EAClC;AACA,SAAO,QAAQ,OAAO,CAAC,QAAQ,CAAC,UAAU,IAAI,GAAG,CAAC;AACtD;"}

package/dist/access/useCan.js

@@ -0,0 +1,12 @@
+import { useToolkitSettings } from "../toolkit/toolkitContext.js";
+function useCan(access) {
+  return useToolkitSettings().canAccess(access);
+}
+function useAccessChecker() {
+  return useToolkitSettings().canAccess;
+}
+export {
+  useAccessChecker,
+  useCan
+};
+//# sourceMappingURL=useCan.js.map

package/dist/access/useCan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCan.js","sources":["../../src/access/useCan.js"],"sourcesContent":["// ¿Esta sesión puede ver esto? Con la regla que el proyecto le dio a ToolkitProvider (canAccess).\n//\n//   const canCancel = useCan({ability: 'orders.cancel'});\n//   {canCancel && <Button>Cancelar pedido</Button>}\n//\n// Hook genérico del paquete: function (regla de la casa).\nimport {useToolkitSettings} from '@/toolkit/toolkitContext.js';\n\n/**\n * @param {object|undefined|null} access la regla (accessRules.js); sin ella, sí\n * @returns {boolean}\n */\nexport function useCan(access) {\n    return useToolkitSettings().canAccess(access);\n}\n\n/**\n * La regla del proyecto, para preguntar por varias cosas a la vez (p. ej. armar el menú).\n *\n * @returns {(access: object|undefined|null) => boolean}\n */\nexport function useAccessChecker() {\n    return useToolkitSettings().canAccess;\n}\n"],"names":[],"mappings":";AAYO,SAAS,OAAO,QAAQ;AAC3B,SAAO,mBAAkB,EAAG,UAAU,MAAM;AAChD;AAOO,SAAS,mBAAmB;AAC/B,SAAO,mBAAkB,EAAG;AAChC;"}

package/dist/account/AccountProvider.js

@@ -0,0 +1,58 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useCallback, useRef, useEffect, useMemo, useContext } from "react";
+import { missingConnectorFunctionsOf } from "./accountConnector.js";
+import { createAccessChecker } from "../access/accessRules.js";
+import ErrorPage, { ERROR_PAGE_KIND } from "../ui/layout/ErrorPage.js";
+import FullPageLoader from "../ui/layout/FullPageLoader.js";
+const AccountContext = createContext(null);
+const NOT_LOADED = void 0;
+function AccountProvider({ connector, refreshKey, initialSession = NOT_LOADED, children }) {
+  const missingFunctions = missingConnectorFunctionsOf(connector);
+  if (missingFunctions.length > 0) {
+    throw new Error(`Al conector de la cuenta le faltan estas funciones: ${missingFunctions.join(", ")}`);
+  }
+  const [session, setSession] = useState(initialSession);
+  const [loadError, setLoadError] = useState(null);
+  const refreshSession = useCallback(async () => {
+    try {
+      setSession(await connector.loadSession());
+      setLoadError(null);
+    } catch (error) {
+      setLoadError(error);
+    }
+  }, [connector]);
+  const signOut = useCallback(async () => {
+    await connector.signOut();
+    setSession(null);
+  }, [connector]);
+  const skipsFirstLoad = useRef(initialSession !== NOT_LOADED);
+  useEffect(() => {
+    if (skipsFirstLoad.current) {
+      skipsFirstLoad.current = false;
+      return;
+    }
+    refreshSession();
+  }, [refreshSession, refreshKey]);
+  const canAccess = useMemo(() => createAccessChecker({ abilities: session?.abilities ?? [], roles: session?.roles ?? [] }), [session]);
+  const value = useMemo(() => ({ connector, session: session ?? null, refreshSession, signOut }), [connector, session, refreshSession, signOut]);
+  if (loadError && session === NOT_LOADED) {
+    return /* @__PURE__ */ jsx(ErrorPage, { kind: ERROR_PAGE_KIND.serverError, text: loadError.message, onRetry: refreshSession });
+  }
+  if (session === NOT_LOADED) {
+    return /* @__PURE__ */ jsx(FullPageLoader, {});
+  }
+  return /* @__PURE__ */ jsx(AccountContext.Provider, { value, children: children(canAccess) });
+}
+function useAccount() {
+  const account = useContext(AccountContext);
+  if (!account) {
+    throw new Error("useAccount necesita estar dentro de <AccountProvider>");
+  }
+  return account;
+}
+export {
+  AccountProvider as default,
+  useAccount
+};
+//# sourceMappingURL=AccountProvider.js.map

package/dist/account/AccountProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountProvider.js","sources":["../../src/account/AccountProvider.jsx"],"sourcesContent":["// La cuenta al alcance de toda la app: carga la sesión al abrir (connector.loadSession) y la reparte. Las pantallas de la\n// cuenta y la barra la leen con useAccount; el menú, las rutas y los botones preguntan sus permisos con la regla que sale de\n// aquí (createAccessChecker), que se le pasa a ToolkitProvider:\n//\n//   <AccountProvider connector={accountConnector}>\n//       {(canAccess) => <ToolkitProvider canAccess={canAccess} …>…</ToolkitProvider>}\n//   </AccountProvider>\n//\n// Mientras llega la primera respuesta se ve la pantalla de carga (sin ella, el menú se pintaría vacío un instante); si el\n// servidor no contesta, la página de error con «Intentar de nuevo», no la de entrar (no es que no haya sesión).\n//\n// Genérico del paquete: function (regla de la casa).\nimport {createContext, useCallback, useContext, useEffect, useMemo, useRef, useState} from 'react';\n\nimport {missingConnectorFunctionsOf} from '@/account/accountConnector.js';\nimport {createAccessChecker} from '@/access/accessRules.js';\nimport ErrorPage, {ERROR_PAGE_KIND} from '@/ui/layout/ErrorPage.jsx';\nimport FullPageLoader from '@/ui/layout/FullPageLoader.jsx';\n\nconst AccountContext = createContext(null);\n// lo que se sabe antes de la primera respuesta: ni dentro ni fuera\nconst NOT_LOADED = undefined;\n\n/**\n * @param {object} props\n * @param {import('@/account/accountConnector.js').AccountConnector} props.connector las llamadas al backend\n * @param {unknown} [props.refreshKey] al cambiar, la sesión se vuelve a leer (p. ej. el idioma, si el backend manda los\n *     nombres de los perfiles traducidos)\n * @param {import('@/account/accountConnector.js').AccountSession|null} [props.initialSession] la sesión que ya se conoce\n *     (p. ej. la que leyó el servidor al pintar): se usa sin esperar la primera respuesta\n * @param {(canAccess: (access: object|null|undefined) => boolean) => import('react').ReactNode} props.children recibe la\n *     regla de permisos de la sesión\n */\nexport default function AccountProvider({connector, refreshKey, initialSession = NOT_LOADED, children}) {\n    // guard clause: un conector incompleto es un error de quien lo escribió; se avisa al arrancar y no al picar un botón\n    const missingFunctions = missingConnectorFunctionsOf(connector);\n    if (missingFunctions.length > 0) {\n        throw new Error(`Al conector de la cuenta le faltan estas funciones: ${missingFunctions.join(', ')}`);\n    }\n\n    const [session, setSession] = useState(initialSession);\n    const [loadError, setLoadError] = useState(null);\n\n    const refreshSession = useCallback(async () => {\n        try {\n            setSession(await connector.loadSession());\n            setLoadError(null);\n        } catch (error) {\n            setLoadError(error);\n        }\n    }, [connector]);\n\n    const signOut = useCallback(async () => {\n        await connector.signOut();\n        setSession(null);\n    }, [connector]);\n\n    // con la sesión ya conocida no se pide al abrir; sí cuando cambia refreshKey\n    const skipsFirstLoad = useRef(initialSession !== NOT_LOADED);\n    useEffect(() => {\n        if (skipsFirstLoad.current) {\n            skipsFirstLoad.current = false;\n            return;\n        }\n        refreshSession();\n    }, [refreshSession, refreshKey]);\n\n    const canAccess = useMemo(() => createAccessChecker({abilities: session?.abilities ?? [], roles: session?.roles ?? []}), [session]);\n    const value = useMemo(() => ({connector, session: session ?? null, refreshSession, signOut}), [connector, session, refreshSession, signOut]);\n\n    if (loadError && session === NOT_LOADED) {\n        return <ErrorPage kind={ERROR_PAGE_KIND.serverError} text={loadError.message} onRetry={refreshSession} />;\n    }\n    if (session === NOT_LOADED) {\n        return <FullPageLoader />;\n    }\n    return <AccountContext.Provider value={value}>{children(canAccess)}</AccountContext.Provider>;\n}\n\n/**\n * La cuenta: {session, refreshSession, signOut, connector}. session es null si nadie está dentro.\n *\n * @returns {{session: import('@/account/accountConnector.js').AccountSession|null, refreshSession: () => Promise<void>, signOut: () => Promise<void>, connector: import('@/account/accountConnector.js').AccountConnector}}\n */\nexport function useAccount() {\n    const account = useContext(AccountContext);\n    if (!account) {\n        throw new Error('useAccount necesita estar dentro de <AccountProvider>');\n    }\n    return account;\n}\n"],"names":[],"mappings":";;;;;;;AAmBA,MAAM,iBAAiB,cAAc,IAAI;AAEzC,MAAM,aAAa;AAYnB,SAAwB,gBAAgB,EAAC,WAAW,YAAY,iBAAiB,YAAY,YAAW;AAEpG,QAAM,mBAAmB,4BAA4B,SAAS;AAC9D,MAAI,iBAAiB,SAAS,GAAG;AAC7B,UAAM,IAAI,MAAM,uDAAuD,iBAAiB,KAAK,IAAI,CAAC,EAAE;AAAA,EACxG;AAEA,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,cAAc;AACrD,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,IAAI;AAE/C,QAAM,iBAAiB,YAAY,YAAY;AAC3C,QAAI;AACA,iBAAW,MAAM,UAAU,aAAa;AACxC,mBAAa,IAAI;AAAA,IACrB,SAAS,OAAO;AACZ,mBAAa,KAAK;AAAA,IACtB;AAAA,EACJ,GAAG,CAAC,SAAS,CAAC;AAEd,QAAM,UAAU,YAAY,YAAY;AACpC,UAAM,UAAU,QAAA;AAChB,eAAW,IAAI;AAAA,EACnB,GAAG,CAAC,SAAS,CAAC;AAGd,QAAM,iBAAiB,OAAO,mBAAmB,UAAU;AAC3D,YAAU,MAAM;AACZ,QAAI,eAAe,SAAS;AACxB,qBAAe,UAAU;AACzB;AAAA,IACJ;AACA,mBAAA;AAAA,EACJ,GAAG,CAAC,gBAAgB,UAAU,CAAC;AAE/B,QAAM,YAAY,QAAQ,MAAM,oBAAoB,EAAC,WAAW,SAAS,aAAa,CAAA,GAAI,OAAO,SAAS,SAAS,CAAA,EAAC,CAAE,GAAG,CAAC,OAAO,CAAC;AAClI,QAAM,QAAQ,QAAQ,OAAO,EAAC,WAAW,SAAS,WAAW,MAAM,gBAAgB,QAAA,IAAW,CAAC,WAAW,SAAS,gBAAgB,OAAO,CAAC;AAE3I,MAAI,aAAa,YAAY,YAAY;AACrC,WAAO,oBAAC,aAAU,MAAM,gBAAgB,aAAa,MAAM,UAAU,SAAS,SAAS,eAAA,CAAgB;AAAA,EAC3G;AACA,MAAI,YAAY,YAAY;AACxB,+BAAQ,gBAAA,EAAe;AAAA,EAC3B;AACA,6BAAQ,eAAe,UAAf,EAAwB,OAAe,UAAA,SAAS,SAAS,GAAE;AACvE;AAOO,SAAS,aAAa;AACzB,QAAM,UAAU,WAAW,cAAc;AACzC,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,MAAM,uDAAuD;AAAA,EAC3E;AACA,SAAO;AACX;"}

package/dist/account/AccountSecuritySection.js

@@ -0,0 +1,81 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useMemo } from "react";
+import Alert from "@mui/material/Alert";
+import Skeleton from "@mui/material/Skeleton";
+import Stack from "@mui/material/Stack";
+import Typography from "@mui/material/Typography";
+import { useAccount } from "./AccountProvider.js";
+import DemoTotpCodeButton from "./DemoTotpCodeButton.js";
+import ChangePasswordForm from "../forms/auth/ChangePasswordForm.js";
+import TwoStepVerificationCard from "../forms/security/TwoStepVerificationCard.js";
+import ActivityLog from "../security/ActivityLog.js";
+import { createPasskey, passkeysSupported } from "../security/passkeys.js";
+import SessionsCard from "../security/SessionsCard.js";
+import { useToolkitTranslation } from "../toolkit/useToolkitTranslation.js";
+import SectionCard from "../ui/layout/SectionCard.js";
+const FORM_MAX_WIDTH = 520;
+const LOADING_HEIGHT_PIXELS = 220;
+function AccountSecuritySection({ showPasswordChange = true, texts }) {
+  const { t } = useToolkitTranslation("account", texts);
+  const { connector, session } = useAccount();
+  const [security, setSecurity] = useState(null);
+  const [sessions, setSessions] = useState(null);
+  const [events, setEvents] = useState(null);
+  const [loadError, setLoadError] = useState(null);
+  const isDemo = typeof connector.demoTotpCode === "function";
+  const refreshActivity = useCallback(() => connector.listActivity().then(setEvents).catch((error) => setLoadError(error.message)), [connector]);
+  const refreshSessions = useCallback(() => connector.listSessions().then(setSessions).catch((error) => setLoadError(error.message)), [connector]);
+  useEffect(() => {
+    connector.loadSecurity().then(setSecurity).catch((error) => setLoadError(error.message));
+    refreshSessions();
+    refreshActivity();
+  }, [connector, refreshActivity, refreshSessions]);
+  const actions = useMemo(() => ({
+    addPasskey: async (name) => connector.savePasskey({ name, credential: await createPasskey(await connector.passkeyRegistrationOptions()) }),
+    removePasskey: (passkey, password) => connector.removePasskey({ passkeyId: passkey.id, password }),
+    startTotp: async () => ({
+      ...await connector.startTotp(),
+      // en la demostración, el atajo del código abajo del campo
+      extra: isDemo ? /* @__PURE__ */ jsx(DemoTotpCodeButton, { loadCode: connector.demoTotpCode }) : void 0
+    }),
+    confirmTotp: (code) => connector.confirmTotp(code),
+    disableTotp: (password) => connector.disableTotp(password),
+    regenerateRecoveryCodes: (password) => connector.regenerateRecoveryCodes(password)
+  }), [connector, isDemo]);
+  const changeSecurity = (nextSecurity) => {
+    setSecurity(nextSecurity);
+    refreshActivity();
+  };
+  return /* @__PURE__ */ jsxs(Stack, { spacing: 3, children: [
+    loadError && /* @__PURE__ */ jsx(Alert, { severity: "error", children: loadError }),
+    showPasswordChange && /* @__PURE__ */ jsxs(SectionCard, { title: t("profile.password.title"), children: [
+      /* @__PURE__ */ jsx(Typography, { variant: "body2", color: "text.secondary", sx: { mb: 2 }, children: t("profile.password.text") }),
+      /* @__PURE__ */ jsx(Stack, { sx: { maxWidth: FORM_MAX_WIDTH }, children: /* @__PURE__ */ jsx(ChangePasswordForm, { onSubmit: async (values) => {
+        await connector.changePassword(values);
+        refreshActivity();
+      } }) })
+    ] }),
+    security ? /* @__PURE__ */ jsx(
+      TwoStepVerificationCard,
+      {
+        security,
+        onSecurityChange: changeSecurity,
+        actions,
+        canUsePasskeys: passkeysSupported(),
+        account: session?.user.email,
+        passkeyNotice: isDemo ? t("demo.passkeyNote") : void 0
+      }
+    ) : /* @__PURE__ */ jsx(Skeleton, { variant: "rounded", height: LOADING_HEIGHT_PIXELS }),
+    isDemo && /* @__PURE__ */ jsx(Alert, { severity: "info", children: t("demo.securityNote") }),
+    /* @__PURE__ */ jsx(SessionsCard, { sessions, onCloseOthers: connector.closeOtherSessions, onClosed: () => {
+      refreshSessions();
+      refreshActivity();
+    } }),
+    /* @__PURE__ */ jsx(ActivityLog, { events })
+  ] });
+}
+export {
+  AccountSecuritySection as default
+};
+//# sourceMappingURL=AccountSecuritySection.js.map

package/dist/account/AccountSecuritySection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountSecuritySection.js","sources":["../../src/account/AccountSecuritySection.jsx"],"sourcesContent":["// La seguridad de la cuenta, completa: cambiar la contraseña (ChangePasswordForm), la verificación en dos pasos\n// (TwoStepVerificationCard: llaves de acceso, app autenticadora y códigos de recuperación), las sesiones abiertas\n// (SessionsCard) y la bitácora (ActivityLog). Todo lo del servidor sale del conector de la cuenta.\n//\n// Las llaves de acceso se crean aquí con el navegador (createPasskey) y la respuesta va al servidor (savePasskey). La\n// bitácora se vuelve a pedir después de cada cambio: así se ve aparecer lo que se acaba de hacer.\n//\n// Genérico del paquete: function (regla de la casa).\nimport {useCallback, useEffect, useMemo, useState} from 'react';\nimport Alert from '@mui/material/Alert';\nimport Skeleton from '@mui/material/Skeleton';\nimport Stack from '@mui/material/Stack';\nimport Typography from '@mui/material/Typography';\n\nimport {useAccount} from '@/account/AccountProvider.jsx';\nimport DemoTotpCodeButton from '@/account/DemoTotpCodeButton.jsx';\nimport ChangePasswordForm from '@/forms/auth/ChangePasswordForm.jsx';\nimport TwoStepVerificationCard from '@/forms/security/TwoStepVerificationCard.jsx';\nimport ActivityLog from '@/security/ActivityLog.jsx';\nimport {createPasskey, passkeysSupported} from '@/security/passkeys.js';\nimport SessionsCard from '@/security/SessionsCard.jsx';\nimport {useToolkitTranslation} from '@/toolkit/useToolkitTranslation.js';\nimport SectionCard from '@/ui/layout/SectionCard.jsx';\n\n// lo ancho del formulario de la contraseña: un renglón cómodo\nconst FORM_MAX_WIDTH = 520;\nconst LOADING_HEIGHT_PIXELS = 220;\n\n/**\n * @param {object} props\n * @param {boolean} [props.showPasswordChange] por omisión sí\n * @param {object} [props.texts] los textos que cambian, con la forma de `account` en los textos del paquete\n */\nexport default function AccountSecuritySection({showPasswordChange = true, texts}) {\n    const {t} = useToolkitTranslation('account', texts);\n    const {connector, session} = useAccount();\n    const [security, setSecurity] = useState(null);\n    const [sessions, setSessions] = useState(null);\n    const [events, setEvents] = useState(null);\n    const [loadError, setLoadError] = useState(null);\n    const isDemo = typeof connector.demoTotpCode === 'function';\n\n    const refreshActivity = useCallback(() => connector.listActivity().then(setEvents).catch((error) => setLoadError(error.message)), [connector]);\n    const refreshSessions = useCallback(() => connector.listSessions().then(setSessions).catch((error) => setLoadError(error.message)), [connector]);\n\n    useEffect(() => {\n        connector.loadSecurity().then(setSecurity).catch((error) => setLoadError(error.message));\n        refreshSessions();\n        refreshActivity();\n    }, [connector, refreshActivity, refreshSessions]);\n\n    // lo que hace la tarjeta de dos pasos en cada caso, con el conector\n    const actions = useMemo(() => ({\n        addPasskey: async (name) => connector.savePasskey({name, credential: await createPasskey(await connector.passkeyRegistrationOptions())}),\n        removePasskey: (passkey, password) => connector.removePasskey({passkeyId: passkey.id, password}),\n        startTotp: async () => ({\n            ...await connector.startTotp(),\n            // en la demostración, el atajo del código abajo del campo\n            extra: isDemo ? <DemoTotpCodeButton loadCode={connector.demoTotpCode} /> : undefined,\n        }),\n        confirmTotp: (code) => connector.confirmTotp(code),\n        disableTotp: (password) => connector.disableTotp(password),\n        regenerateRecoveryCodes: (password) => connector.regenerateRecoveryCodes(password),\n    }), [connector, isDemo]);\n\n    const changeSecurity = (nextSecurity) => {\n        setSecurity(nextSecurity);\n        refreshActivity();\n    };\n\n    return (\n        <Stack spacing={3}>\n            {loadError && <Alert severity=\"error\">{loadError}</Alert>}\n            {showPasswordChange && (\n                <SectionCard title={t('profile.password.title')}>\n                    <Typography variant=\"body2\" color=\"text.secondary\" sx={{mb: 2}}>{t('profile.password.text')}</Typography>\n                    <Stack sx={{maxWidth: FORM_MAX_WIDTH}}>\n                        <ChangePasswordForm onSubmit={async (values) => {\n                            await connector.changePassword(values);\n                            refreshActivity();\n                        }} />\n                    </Stack>\n                </SectionCard>\n            )}\n            {security\n                ? <TwoStepVerificationCard security={security} onSecurityChange={changeSecurity} actions={actions}\n                                           canUsePasskeys={passkeysSupported()} account={session?.user.email}\n                                           // en la demostración la llave es de verdad pero el servidor se olvida al recargar:\n                                           // se avisa antes de crearla para que nadie se quede con una llave huérfana\n                                           passkeyNotice={isDemo ? t('demo.passkeyNote') : undefined} />\n                : <Skeleton variant=\"rounded\" height={LOADING_HEIGHT_PIXELS} />}\n            {isDemo && <Alert severity=\"info\">{t('demo.securityNote')}</Alert>}\n            <SessionsCard sessions={sessions} onCloseOthers={connector.closeOtherSessions} onClosed={() => {\n                refreshSessions();\n                refreshActivity();\n            }} />\n            <ActivityLog events={events} />\n        </Stack>\n    );\n}\n"],"names":[],"mappings":"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"}