valtech-components 2.0.983 → 2.0.985

package/esm2022/lib/components/organisms/security-view/security-view.i18n.mjs

@@ -0,0 +1,105 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-security-view`. Auto-registrados en el
+ * constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.Security` por default). Garantiza que nunca haya una key faltante
+ * evaluada por cada change-detection (ver nota en valtech-components/CLAUDE.md
+ * sobre el storm de CD con `val-debug-console`). El consumer puede override
+ * registrando el mismo namespace antes de que el componente monte.
+ *
+ * SOLO incluye las keys que la vista realmente usa.
+ */
+export const SECURITY_VIEW_I18N = {
+    es: {
+        pageTitle: 'Seguridad',
+        pageDescription: 'Contraseñas, MFA y sesiones activas',
+        blocked: 'Dispositivo bloqueado',
+        tokenActionFailed: 'El enlace del email no es válido o expiró.',
+        loginAttemptTitle: 'Confirmar inicio de sesión',
+        loginAttemptBody: 'Detectamos un inicio de sesión en este dispositivo. Si fuiste tú, no tienes que hacer nada. Si no lo reconoces, bloquéalo.',
+        loginAttemptMine: 'Sí, fui yo',
+        loginAttemptBlock: 'No fui yo — bloquear',
+        loginAttemptClose: 'Cerrar',
+        loginAttemptDone: 'Dispositivo bloqueado. Restablece tu contraseña para reforzar tu cuenta.',
+        loginAttemptUnknownDevice: 'Dispositivo desconocido',
+        sessionsTitle: 'Sesiones activas',
+        sessionsTitleCount: 'Sesiones activas ({n})',
+        sessionsLoading: 'Cargando sesiones…',
+        sessionsEmpty: 'No hay sesiones activas.',
+        sessionsThis: 'Esta sesión',
+        sessionsRevoke: 'Cerrar',
+        sessionsRevokeAll: 'Cerrar todas las demás',
+        sessionsViewAll: 'Ver todas',
+        sessionsModalTitle: 'Todas las sesiones activas',
+        sessionsRevoked: 'Sesión cerrada.',
+        sessionsAllRevoked: 'Todas las demás sesiones fueron cerradas.',
+        sessionsError: 'No se pudo completar la operación.',
+        revokeAllConfirmTitle: 'Cerrar todas las otras sesiones',
+        revokeAllConfirmMessage: 'Vas a cerrar todas tus sesiones excepto la actual. Tendrás que volver a iniciar sesión en los otros dispositivos.',
+        revokeAllConfirm: 'Cerrar todas',
+        cancel: 'Cancelar',
+        quickActionsTitle: 'Otras opciones',
+        changePassword: 'Cambiar contraseña',
+        changePasswordDesc: 'Actualiza tu contraseña de acceso',
+        changeEmail: 'Cambiar email',
+        changeEmailDesc: 'Actualiza el correo electrónico de tu cuenta',
+        mfa: 'Autenticación de dos pasos (MFA)',
+        mfaDesc: 'Agrega un segundo factor a tu inicio de sesión',
+        sessions: 'Sesiones activas',
+        sessionsDesc: 'Revisa y cierra sesiones en otros dispositivos',
+        policiesTitle: 'Políticas relacionadas',
+        privacyLink: 'Política de Privacidad',
+        cookiesLink: 'Política de Cookies',
+        dataUsageLink: 'Uso de Datos',
+        termsLink: 'Términos y Condiciones',
+        thirdPartyLink: 'Software y Servicios de Terceros',
+        legalNoticeLink: 'Aviso Legal',
+        soonHint: 'Próximamente',
+    },
+    en: {
+        pageTitle: 'Security',
+        pageDescription: 'Passwords, MFA, and active sessions',
+        blocked: 'Device blocked',
+        tokenActionFailed: 'The email link is invalid or has expired.',
+        loginAttemptTitle: 'Confirm sign-in',
+        loginAttemptBody: "We detected a sign-in on this device. If it was you, there's nothing to do. If you don't recognize it, block it.",
+        loginAttemptMine: 'Yes, it was me',
+        loginAttemptBlock: 'Not me — block it',
+        loginAttemptClose: 'Close',
+        loginAttemptDone: 'Device blocked. Reset your password to secure your account.',
+        loginAttemptUnknownDevice: 'Unknown device',
+        sessionsTitle: 'Active sessions',
+        sessionsTitleCount: 'Active sessions ({n})',
+        sessionsLoading: 'Loading sessions…',
+        sessionsEmpty: 'No active sessions.',
+        sessionsThis: 'This session',
+        sessionsRevoke: 'End',
+        sessionsRevokeAll: 'End all others',
+        sessionsViewAll: 'View all',
+        sessionsModalTitle: 'All active sessions',
+        sessionsRevoked: 'Session ended.',
+        sessionsAllRevoked: 'All other sessions were ended.',
+        sessionsError: 'Could not complete the operation.',
+        revokeAllConfirmTitle: 'End all other sessions',
+        revokeAllConfirmMessage: "You're about to end every session except this one. You'll need to sign in again on the other devices.",
+        revokeAllConfirm: 'End all',
+        cancel: 'Cancel',
+        quickActionsTitle: 'Other options',
+        changePassword: 'Change password',
+        changePasswordDesc: 'Update your access password',
+        changeEmail: 'Change email',
+        changeEmailDesc: 'Update the email address on your account',
+        mfa: 'Two-step verification (MFA)',
+        mfaDesc: 'Add a second factor to your sign-in',
+        sessions: 'Active sessions',
+        sessionsDesc: 'Review and sign out from other devices',
+        policiesTitle: 'Related policies',
+        privacyLink: 'Privacy Policy',
+        cookiesLink: 'Cookie Policy',
+        dataUsageLink: 'Data Usage',
+        termsLink: 'Terms and Conditions',
+        thirdPartyLink: 'Third-Party Software and Services',
+        legalNoticeLink: 'Legal Notice',
+        soonHint: 'Coming soon',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-view.i18n.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/security-view/security-view.i18n.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAqB;IAClD,EAAE,EAAE;QACF,SAAS,EAAE,WAAW;QACtB,eAAe,EAAE,qCAAqC;QAEtD,OAAO,EAAE,uBAAuB;QAChC,iBAAiB,EAAE,4CAA4C;QAE/D,iBAAiB,EAAE,4BAA4B;QAC/C,gBAAgB,EACd,4HAA4H;QAC9H,gBAAgB,EAAE,YAAY;QAC9B,iBAAiB,EAAE,sBAAsB;QACzC,iBAAiB,EAAE,QAAQ;QAC3B,gBAAgB,EAAE,0EAA0E;QAC5F,yBAAyB,EAAE,yBAAyB;QAEpD,aAAa,EAAE,kBAAkB;QACjC,kBAAkB,EAAE,wBAAwB;QAC5C,eAAe,EAAE,oBAAoB;QACrC,aAAa,EAAE,0BAA0B;QACzC,YAAY,EAAE,aAAa;QAC3B,cAAc,EAAE,QAAQ;QACxB,iBAAiB,EAAE,wBAAwB;QAC3C,eAAe,EAAE,WAAW;QAC5B,kBAAkB,EAAE,4BAA4B;QAChD,eAAe,EAAE,iBAAiB;QAClC,kBAAkB,EAAE,2CAA2C;QAC/D,aAAa,EAAE,oCAAoC;QACnD,qBAAqB,EAAE,iCAAiC;QACxD,uBAAuB,EACrB,mHAAmH;QACrH,gBAAgB,EAAE,cAAc;QAChC,MAAM,EAAE,UAAU;QAElB,iBAAiB,EAAE,gBAAgB;QACnC,cAAc,EAAE,oBAAoB;QACpC,kBAAkB,EAAE,mCAAmC;QACvD,WAAW,EAAE,eAAe;QAC5B,eAAe,EAAE,8CAA8C;QAC/D,GAAG,EAAE,kCAAkC;QACvC,OAAO,EAAE,gDAAgD;QACzD,QAAQ,EAAE,kBAAkB;QAC5B,YAAY,EAAE,gDAAgD;QAE9D,aAAa,EAAE,wBAAwB;QACvC,WAAW,EAAE,wBAAwB;QACrC,WAAW,EAAE,qBAAqB;QAClC,aAAa,EAAE,cAAc;QAC7B,SAAS,EAAE,wBAAwB;QACnC,cAAc,EAAE,kCAAkC;QAClD,eAAe,EAAE,aAAa;QAE9B,QAAQ,EAAE,cAAc;KACzB;IACD,EAAE,EAAE;QACF,SAAS,EAAE,UAAU;QACrB,eAAe,EAAE,qCAAqC;QAEtD,OAAO,EAAE,gBAAgB;QACzB,iBAAiB,EAAE,2CAA2C;QAE9D,iBAAiB,EAAE,iBAAiB;QACpC,gBAAgB,EACd,kHAAkH;QACpH,gBAAgB,EAAE,gBAAgB;QAClC,iBAAiB,EAAE,mBAAmB;QACtC,iBAAiB,EAAE,OAAO;QAC1B,gBAAgB,EAAE,6DAA6D;QAC/E,yBAAyB,EAAE,gBAAgB;QAE3C,aAAa,EAAE,iBAAiB;QAChC,kBAAkB,EAAE,uBAAuB;QAC3C,eAAe,EAAE,mBAAmB;QACpC,aAAa,EAAE,qBAAqB;QACpC,YAAY,EAAE,cAAc;QAC5B,cAAc,EAAE,KAAK;QACrB,iBAAiB,EAAE,gBAAgB;QACnC,eAAe,EAAE,UAAU;QAC3B,kBAAkB,EAAE,qBAAqB;QACzC,eAAe,EAAE,gBAAgB;QACjC,kBAAkB,EAAE,gCAAgC;QACpD,aAAa,EAAE,mCAAmC;QAClD,qBAAqB,EAAE,wBAAwB;QAC/C,uBAAuB,EACrB,uGAAuG;QACzG,gBAAgB,EAAE,SAAS;QAC3B,MAAM,EAAE,QAAQ;QAEhB,iBAAiB,EAAE,eAAe;QAClC,cAAc,EAAE,iBAAiB;QACjC,kBAAkB,EAAE,6BAA6B;QACjD,WAAW,EAAE,cAAc;QAC3B,eAAe,EAAE,0CAA0C;QAC3D,GAAG,EAAE,6BAA6B;QAClC,OAAO,EAAE,qCAAqC;QAC9C,QAAQ,EAAE,iBAAiB;QAC3B,YAAY,EAAE,wCAAwC;QAEtD,aAAa,EAAE,kBAAkB;QACjC,WAAW,EAAE,gBAAgB;QAC7B,WAAW,EAAE,eAAe;QAC5B,aAAa,EAAE,YAAY;QAC3B,SAAS,EAAE,sBAAsB;QACjC,cAAc,EAAE,mCAAmC;QACnD,eAAe,EAAE,cAAc;QAE/B,QAAQ,EAAE,aAAa;KACxB;CACF,CAAC","sourcesContent":["import { LanguagesContent } from '../../../services/i18n/types';\n\n/**\n * Defaults i18n (es/en) embebidos en `val-security-view`. Auto-registrados en el\n * constructor del componente si el consumer no proveyó el namespace\n * (`Settings.Security` por default). Garantiza que nunca haya una key faltante\n * evaluada por cada change-detection (ver nota en valtech-components/CLAUDE.md\n * sobre el storm de CD con `val-debug-console`). El consumer puede override\n * registrando el mismo namespace antes de que el componente monte.\n *\n * SOLO incluye las keys que la vista realmente usa.\n */\nexport const SECURITY_VIEW_I18N: LanguagesContent = {\n  es: {\n    pageTitle: 'Seguridad',\n    pageDescription: 'Contraseñas, MFA y sesiones activas',\n\n    blocked: 'Dispositivo bloqueado',\n    tokenActionFailed: 'El enlace del email no es válido o expiró.',\n\n    loginAttemptTitle: 'Confirmar inicio de sesión',\n    loginAttemptBody:\n      'Detectamos un inicio de sesión en este dispositivo. Si fuiste tú, no tienes que hacer nada. Si no lo reconoces, bloquéalo.',\n    loginAttemptMine: 'Sí, fui yo',\n    loginAttemptBlock: 'No fui yo — bloquear',\n    loginAttemptClose: 'Cerrar',\n    loginAttemptDone: 'Dispositivo bloqueado. Restablece tu contraseña para reforzar tu cuenta.',\n    loginAttemptUnknownDevice: 'Dispositivo desconocido',\n\n    sessionsTitle: 'Sesiones activas',\n    sessionsTitleCount: 'Sesiones activas ({n})',\n    sessionsLoading: 'Cargando sesiones…',\n    sessionsEmpty: 'No hay sesiones activas.',\n    sessionsThis: 'Esta sesión',\n    sessionsRevoke: 'Cerrar',\n    sessionsRevokeAll: 'Cerrar todas las demás',\n    sessionsViewAll: 'Ver todas',\n    sessionsModalTitle: 'Todas las sesiones activas',\n    sessionsRevoked: 'Sesión cerrada.',\n    sessionsAllRevoked: 'Todas las demás sesiones fueron cerradas.',\n    sessionsError: 'No se pudo completar la operación.',\n    revokeAllConfirmTitle: 'Cerrar todas las otras sesiones',\n    revokeAllConfirmMessage:\n      'Vas a cerrar todas tus sesiones excepto la actual. Tendrás que volver a iniciar sesión en los otros dispositivos.',\n    revokeAllConfirm: 'Cerrar todas',\n    cancel: 'Cancelar',\n\n    quickActionsTitle: 'Otras opciones',\n    changePassword: 'Cambiar contraseña',\n    changePasswordDesc: 'Actualiza tu contraseña de acceso',\n    changeEmail: 'Cambiar email',\n    changeEmailDesc: 'Actualiza el correo electrónico de tu cuenta',\n    mfa: 'Autenticación de dos pasos (MFA)',\n    mfaDesc: 'Agrega un segundo factor a tu inicio de sesión',\n    sessions: 'Sesiones activas',\n    sessionsDesc: 'Revisa y cierra sesiones en otros dispositivos',\n\n    policiesTitle: 'Políticas relacionadas',\n    privacyLink: 'Política de Privacidad',\n    cookiesLink: 'Política de Cookies',\n    dataUsageLink: 'Uso de Datos',\n    termsLink: 'Términos y Condiciones',\n    thirdPartyLink: 'Software y Servicios de Terceros',\n    legalNoticeLink: 'Aviso Legal',\n\n    soonHint: 'Próximamente',\n  },\n  en: {\n    pageTitle: 'Security',\n    pageDescription: 'Passwords, MFA, and active sessions',\n\n    blocked: 'Device blocked',\n    tokenActionFailed: 'The email link is invalid or has expired.',\n\n    loginAttemptTitle: 'Confirm sign-in',\n    loginAttemptBody:\n      \"We detected a sign-in on this device. If it was you, there's nothing to do. If you don't recognize it, block it.\",\n    loginAttemptMine: 'Yes, it was me',\n    loginAttemptBlock: 'Not me — block it',\n    loginAttemptClose: 'Close',\n    loginAttemptDone: 'Device blocked. Reset your password to secure your account.',\n    loginAttemptUnknownDevice: 'Unknown device',\n\n    sessionsTitle: 'Active sessions',\n    sessionsTitleCount: 'Active sessions ({n})',\n    sessionsLoading: 'Loading sessions…',\n    sessionsEmpty: 'No active sessions.',\n    sessionsThis: 'This session',\n    sessionsRevoke: 'End',\n    sessionsRevokeAll: 'End all others',\n    sessionsViewAll: 'View all',\n    sessionsModalTitle: 'All active sessions',\n    sessionsRevoked: 'Session ended.',\n    sessionsAllRevoked: 'All other sessions were ended.',\n    sessionsError: 'Could not complete the operation.',\n    revokeAllConfirmTitle: 'End all other sessions',\n    revokeAllConfirmMessage:\n      \"You're about to end every session except this one. You'll need to sign in again on the other devices.\",\n    revokeAllConfirm: 'End all',\n    cancel: 'Cancel',\n\n    quickActionsTitle: 'Other options',\n    changePassword: 'Change password',\n    changePasswordDesc: 'Update your access password',\n    changeEmail: 'Change email',\n    changeEmailDesc: 'Update the email address on your account',\n    mfa: 'Two-step verification (MFA)',\n    mfaDesc: 'Add a second factor to your sign-in',\n    sessions: 'Active sessions',\n    sessionsDesc: 'Review and sign out from other devices',\n\n    policiesTitle: 'Related policies',\n    privacyLink: 'Privacy Policy',\n    cookiesLink: 'Cookie Policy',\n    dataUsageLink: 'Data Usage',\n    termsLink: 'Terms and Conditions',\n    thirdPartyLink: 'Third-Party Software and Services',\n    legalNoticeLink: 'Legal Notice',\n\n    soonHint: 'Coming soon',\n  },\n};\n"]}

package/esm2022/lib/components/organisms/security-view/security.routes.mjs

@@ -0,0 +1,29 @@
+import { SecurityViewComponent } from './security-view.component';
+/**
+ * Helper para montar la vista Seguridad (`val-security-view`) como ruta en una
+ * app del factory. El `config` se pasa por route `data` (`securityConfig`) y el
+ * componente lo lee como fallback de su `@Input() config`.
+ *
+ * @example
+ * ```ts
+ * // settings.routes.ts
+ * export const settingsRoutes: Routes = [
+ *   ...provideValtechSecurityRoutes(),
+ *   { path: 'preferences', loadComponent: () => ... },
+ * ];
+ *
+ * // con config acotada:
+ * ...provideValtechSecurityRoutes({ config: { showPolicies: false } }),
+ * ...provideValtechSecurityRoutes({ config: { homeRoute: '/app/dashboard' } }),
+ * ```
+ */
+export function provideValtechSecurityRoutes(opts) {
+    return [
+        {
+            path: opts?.path ?? 'security',
+            component: SecurityViewComponent,
+            data: { securityConfig: opts?.config },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/security-view/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL3NlY3VyaXR5LXZpZXcvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29uZmlndXJhY2nDs24gYWNvdGFkYSBkZSBgdmFsLXNlY3VyaXR5LXZpZXdgIChvYmplY3QtZmlyc3QpLiBUcmVzIGVqZXMgZGVcbiAqIHZhcmlhY2nDs24gcGVybWl0aWRvcyDigJQgKipOQURBIGRlIHNsb3RzIGFyYml0cmFyaW9zKiogKEFEUi0wMjE6IHVuYSB2aXN0YVxuICogZnVsbC1mZWF0dXJlIG5vIGFicmUgc2xvdHM7IHNpIGZhbHRhIGFsZ28sIHNlIHByb211ZXZlIHVuIG51ZXZvIHB1bnRvIGRlXG4gKiBleHRlbnNpw7NuKTpcbiAqXG4gKiAgLSAqKnNlY2Npb25lcyB2aXNpYmxlcyoqIOKAlCBnYXRlYW4gZWwgcmVuZGVyIGRlIGNhZGEgYmxvcXVlIChzZXNpb25lcyxcbiAqICAgIGFjdGlvbi1jYXJkcyBkZSBjYW1iaWFyIGNvbnRyYXNlw7FhIC8gZW1haWwgLyBNRkEsIHBvbMOtdGljYXMgbGVnYWxlcykuXG4gKiAgLSAqKmJyYW5kaW5nKiog4oCUIGBpMThuTmFtZXNwYWNlYCBwYXJhIHJlc29sdmVyIGxvcyB0ZXh0b3MgKGRlZmF1bHRcbiAqICAgIGAnU2V0dGluZ3MuU2VjdXJpdHknYCkuXG4gKiAgLSAqKmNvbXBvcnRhbWllbnRvIC8gY2FsbGJhY2tzKiog4oCUIG1hbmVqbyBkZSBkZWVwLWxpbmtzIGRlbCBlbWFpbFxuICogICAgKGA/dG9rZW5gL2A/YWN0aW9uYC9gP21mYUNvZGVgKSwgcnV0YSBkZSBcImhvbWVcIiB0cmFzIGNvbXBsZXRhciBNRkEgeSB1blxuICogICAgaG9vayBvcGNpb25hbCBgb25NZmFDb21wbGV0ZWRgLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNlY3VyaXR5Vmlld0NvbmZpZyB7XG4gIC8qKiBNdWVzdHJhIGxhIHNlY2Npw7NuIGRlIHNlc2lvbmVzIGFjdGl2YXMuIERlZmF1bHQgYHRydWVgLiAqL1xuICBzaG93U2Vzc2lvbnM/OiBib29sZWFuO1xuICAvKiogSW5jbHV5ZSBsYSBhY3Rpb24tY2FyZCBcIkNhbWJpYXIgY29udHJhc2XDsWFcIi4gRGVmYXVsdCBgdHJ1ZWAuICovXG4gIHNob3dDaGFuZ2VQYXNzd29yZD86IGJvb2xlYW47XG4gIC8qKiBJbmNsdXllIGxhIGFjdGlvbi1jYXJkIFwiQ2FtYmlhciBlbWFpbFwiLiBEZWZhdWx0IGB0cnVlYC4gKi9cbiAgc2hvd0NoYW5nZUVtYWlsPzogYm9vbGVhbjtcbiAgLyoqIEluY2x1eWUgbGEgYWN0aW9uLWNhcmQgXCJBdXRlbnRpY2FjacOzbiBkZSBkb3MgcGFzb3MgKE1GQSlcIi4gRGVmYXVsdCBgdHJ1ZWAuICovXG4gIHNob3dNZmE/OiBib29sZWFuO1xuICAvKiogTXVlc3RyYSBsYSBzZWNjacOzbiBkZSBwb2zDrXRpY2FzIGxlZ2FsZXMgcmVsYWNpb25hZGFzLiBEZWZhdWx0IGB0cnVlYC4gKi9cbiAgc2hvd1BvbGljaWVzPzogYm9vbGVhbjtcblxuICAvKipcbiAgICogTmFtZXNwYWNlIGkxOG4gY29uIGVsIHF1ZSBsYSB2aXN0YSByZXN1ZWx2ZSBzdXMgdGV4dG9zLlxuICAgKiBEZWZhdWx0IGAnU2V0dGluZ3MuU2VjdXJpdHknYC5cbiAgICovXG4gIGkxOG5OYW1lc3BhY2U/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIEhhYmlsaXRhIGVsIG1hbmVqbyBkZSBsb3MgZGVlcC1saW5rcyBkZWwgZW1haWxcbiAgICogKGA/dG9rZW5gL2A/YWN0aW9uYC9gP21mYUNvZGVgKS4gRGVmYXVsdCBgdHJ1ZWAuIFJlcXVpZXJlIHF1ZSBsYSB2aXN0YSBlc3TDqVxuICAgKiBtb250YWRhIGNvbW8gcnV0YSAoaGF5IGBBY3RpdmF0ZWRSb3V0ZWApOyBlbiBtb2RvIGVtYmViaWRvIHNpbiBydXRhIGVzIG5vLW9wLlxuICAgKi9cbiAgaGFuZGxlRGVlcExpbmtzPzogYm9vbGVhbjtcblxuICAvKipcbiAgICogUnV0YSBhIGxhIHF1ZSBuYXZlZ2FyIHRyYXMgY29tcGxldGFyIE1GQSB2w61hIGRlZXAtbGluay4gRGVmYXVsdCBgJy9hcHAvaG9tZSdgLlxuICAgKiBJZ25vcmFkYSBzaSBzZSBwcm92ZWUgYG9uTWZhQ29tcGxldGVkYC5cbiAgICovXG4gIGhvbWVSb3V0ZT86IHN0cmluZztcblxuICAvKipcbiAgICogSG9vayBpbnZvY2FkbyBjdWFuZG8gZWwgdXN1YXJpbyBjb21wbGV0YSBNRkEgdsOtYSBkZWVwLWxpbmsuIFNpIHNlIHByb3ZlZSwgc2VcbiAgICogbGxhbWEgKiplbiBsdWdhcioqIGRlIG5hdmVnYXIgYSBgaG9tZVJvdXRlYC4gw5p0aWwgcGFyYSBhcHBzIHF1ZSBxdWllcmFuXG4gICAqIGRlY2lkaXIgZWwgZGVzdGlubyBwb3N0LU1GQS5cbiAgICovXG4gIG9uTWZhQ29tcGxldGVkPzogKCkgPT4gdm9pZDtcbn1cbiJdfQ==

package/esm2022/lib/components/organisms/session-list-modal/session-list-modal.component.mjs

@@ -0,0 +1,206 @@
+import { CommonModule } from '@angular/common';
+import { Component, Input, signal } from '@angular/core';
+import { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { ComponentStates } from '../../types';
+import * as i0 from "@angular/core";
+/**
+ * `val-session-list-modal` — modal de "Ver todas las sesiones activas". Organism
+ * compartido entre la vista Seguridad y la vista Cuenta del factory.
+ *
+ * Render reusa el mismo markup de la sección de sesiones inline (mismas clases
+ * CSS) pero sin truncar la lista.
+ *
+ * Inputs (vienen de `componentProps` del ModalService):
+ *  - `sessions` — snapshot inicial (mostrado al abrir)
+ *  - `thisLabel` / `revokeLabel` — i18n strings ya resueltas
+ *  - `onRevoke` — callback async que el parent ejecuta contra el backend; debe
+ *    retornar la lista actualizada para que el modal refresque en sitio.
+ *
+ * `@Output` events NO funcionan con `modalController.create()` — por eso usamos
+ * callback pasado por props + `_modalRef` para dismiss desde dentro.
+ *
+ * Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,
+ * título en el body con `val-display`.
+ */
+export class SessionListModalComponent {
+    constructor() {
+        /** Título del modal (ya traducido). */
+        this.title = '';
+        /** Label del botón cerrar del header (ya traducido). */
+        this.closeLabel = '';
+        /** Label "Esta sesión" (en idioma activo). */
+        this.thisLabel = '';
+        /** Label del botón revoke individual. */
+        this.revokeLabel = '';
+        /** Lista local mutable — refrescada después de cada revoke confirmado. */
+        this.sessionsLocal = signal([]);
+    }
+    /** Snapshot inicial — el modal mantiene su propia copia y la refresca tras revoke. */
+    set sessions(value) {
+        this.sessionsLocal.set([...value]);
+    }
+    close() {
+        this._modalRef?.dismiss(undefined, 'close');
+    }
+    async handleRevoke(sessionId) {
+        if (!this.onRevoke)
+            return;
+        try {
+            const updated = await this.onRevoke(sessionId);
+            this.sessionsLocal.set([...updated]);
+        }
+        catch {
+            // El parent muestra el toast de error; modal no necesita feedback extra.
+        }
+    }
+    get revokeBtn() {
+        return {
+            text: this.revokeLabel,
+            color: 'dark',
+            fill: 'clear',
+            size: 'small',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+        };
+    }
+    deviceIcon(s) {
+        const ua = (s.deviceInfo || '').toLowerCase();
+        const isMobile = /iphone|ipad|ipod|android|mobile/.test(ua);
+        return isMobile ? 'phone-portrait-outline' : 'laptop-outline';
+    }
+    formatMeta(s) {
+        const parts = [];
+        if (s.location)
+            parts.push(s.location);
+        else if (s.ip)
+            parts.push(s.ip);
+        if (s.createdAt)
+            parts.push(new Date(s.createdAt).toLocaleString());
+        return parts.join(' · ');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionListModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SessionListModalComponent, isStandalone: true, selector: "val-session-list-modal", inputs: { sessions: "sessions", title: "title", closeLabel: "closeLabel", thisLabel: "thisLabel", revokeLabel: "revokeLabel", onRevoke: "onRevoke", _modalRef: "_modalRef" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ closeLabel }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: title, size: 'small', color: 'dark' }" />
+      <ul class="sessions">
+        @for (s of sessionsLocal(); track s.sessionId) {
+          <li class="session" [class.session--current]="s.isCurrent">
+            <ion-icon class="session__icon" [name]="deviceIcon(s)" aria-hidden="true" />
+            <div class="session__body">
+              <val-text
+                [props]="{
+                  content: s.deviceInfo || s.deviceId || '—',
+                  size: 'medium',
+                  color: 'dark',
+                  bold: true,
+                }"
+              />
+              <val-text
+                [props]="{
+                  content: formatMeta(s),
+                  size: 'small',
+                  color: 'medium',
+                  bold: false,
+                }"
+              />
+            </div>
+            <div class="session__end">
+              @if (s.isCurrent) {
+                <span class="session__badge">{{ thisLabel }}</span>
+              } @else {
+                <val-button [props]="revokeBtn" (click)="handleRevoke(s.sessionId)" />
+              }
+            </div>
+          </li>
+        }
+      </ul>
+    </ion-content>
+  `, isInline: true, styles: [":host{display:block;height:100%}.sessions{list-style:none;padding:0;margin:0;display:flex;flex-direction:column;gap:10px}.session{display:flex;align-items:center;gap:12px;padding:14px 16px;border-radius:14px;background:var(--ion-color-light, rgba(0, 0, 0, .04));border:1px solid transparent}.session--current{background:#2dd36f1a;border-color:#2dd36f4d}.session__icon{font-size:26px;color:var(--ion-color-dark, #1a1a1a);flex-shrink:0}.session--current .session__icon{color:var(--ion-color-success-shade, #28ba62)}.session__body{display:flex;flex-direction:column;gap:2px;min-width:0;flex:1}.session__end{flex-shrink:0}.session__badge{display:inline-block;padding:4px 10px;font-size:11px;font-weight:700;letter-spacing:.02em;text-transform:uppercase;color:var(--ion-color-success-shade, #28ba62);background:#2dd36f2e;border-radius:999px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionListModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-session-list-modal', standalone: true, imports: [
+                        CommonModule,
+                        IonContent,
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonIcon,
+                        DisplayComponent,
+                        TextComponent,
+                        ButtonComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ closeLabel }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: title, size: 'small', color: 'dark' }" />
+      <ul class="sessions">
+        @for (s of sessionsLocal(); track s.sessionId) {
+          <li class="session" [class.session--current]="s.isCurrent">
+            <ion-icon class="session__icon" [name]="deviceIcon(s)" aria-hidden="true" />
+            <div class="session__body">
+              <val-text
+                [props]="{
+                  content: s.deviceInfo || s.deviceId || '—',
+                  size: 'medium',
+                  color: 'dark',
+                  bold: true,
+                }"
+              />
+              <val-text
+                [props]="{
+                  content: formatMeta(s),
+                  size: 'small',
+                  color: 'medium',
+                  bold: false,
+                }"
+              />
+            </div>
+            <div class="session__end">
+              @if (s.isCurrent) {
+                <span class="session__badge">{{ thisLabel }}</span>
+              } @else {
+                <val-button [props]="revokeBtn" (click)="handleRevoke(s.sessionId)" />
+              }
+            </div>
+          </li>
+        }
+      </ul>
+    </ion-content>
+  `, styles: [":host{display:block;height:100%}.sessions{list-style:none;padding:0;margin:0;display:flex;flex-direction:column;gap:10px}.session{display:flex;align-items:center;gap:12px;padding:14px 16px;border-radius:14px;background:var(--ion-color-light, rgba(0, 0, 0, .04));border:1px solid transparent}.session--current{background:#2dd36f1a;border-color:#2dd36f4d}.session__icon{font-size:26px;color:var(--ion-color-dark, #1a1a1a);flex-shrink:0}.session--current .session__icon{color:var(--ion-color-success-shade, #28ba62)}.session__body{display:flex;flex-direction:column;gap:2px;min-width:0;flex:1}.session__end{flex-shrink:0}.session__badge{display:inline-block;padding:4px 10px;font-size:11px;font-weight:700;letter-spacing:.02em;text-transform:uppercase;color:var(--ion-color-success-shade, #28ba62);background:#2dd36f2e;border-radius:999px}\n"] }]
+        }], propDecorators: { sessions: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], closeLabel: [{
+                type: Input
+            }], thisLabel: [{
+                type: Input
+            }], revokeLabel: [{
+                type: Input
+            }], onRevoke: [{
+                type: Input
+            }], _modalRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-list-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/session-list-modal/session-list-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input, signal } from '@angular/core';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';\n\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { ButtonMetadata, ComponentStates } from '../../types';\n\nimport { SessionInfo } from '../../../services/auth/types';\n\n/**\n * `val-session-list-modal` — modal de \"Ver todas las sesiones activas\". Organism\n * compartido entre la vista Seguridad y la vista Cuenta del factory.\n *\n * Render reusa el mismo markup de la sección de sesiones inline (mismas clases\n * CSS) pero sin truncar la lista.\n *\n * Inputs (vienen de `componentProps` del ModalService):\n *  - `sessions` — snapshot inicial (mostrado al abrir)\n *  - `thisLabel` / `revokeLabel` — i18n strings ya resueltas\n *  - `onRevoke` — callback async que el parent ejecuta contra el backend; debe\n *    retornar la lista actualizada para que el modal refresque en sitio.\n *\n * `@Output` events NO funcionan con `modalController.create()` — por eso usamos\n * callback pasado por props + `_modalRef` para dismiss desde dentro.\n *\n * Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,\n * título en el body con `val-display`.\n */\n@Component({\n  selector: 'val-session-list-modal',\n  standalone: true,\n  imports: [\n    CommonModule,\n    IonContent,\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonIcon,\n    DisplayComponent,\n    TextComponent,\n    ButtonComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\n            <strong>{{ closeLabel }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: title, size: 'small', color: 'dark' }\" />\n      <ul class=\"sessions\">\n        @for (s of sessionsLocal(); track s.sessionId) {\n          <li class=\"session\" [class.session--current]=\"s.isCurrent\">\n            <ion-icon class=\"session__icon\" [name]=\"deviceIcon(s)\" aria-hidden=\"true\" />\n            <div class=\"session__body\">\n              <val-text\n                [props]=\"{\n                  content: s.deviceInfo || s.deviceId || '—',\n                  size: 'medium',\n                  color: 'dark',\n                  bold: true,\n                }\"\n              />\n              <val-text\n                [props]=\"{\n                  content: formatMeta(s),\n                  size: 'small',\n                  color: 'medium',\n                  bold: false,\n                }\"\n              />\n            </div>\n            <div class=\"session__end\">\n              @if (s.isCurrent) {\n                <span class=\"session__badge\">{{ thisLabel }}</span>\n              } @else {\n                <val-button [props]=\"revokeBtn\" (click)=\"handleRevoke(s.sessionId)\" />\n              }\n            </div>\n          </li>\n        }\n      </ul>\n    </ion-content>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n        height: 100%;\n      }\n\n      .sessions {\n        list-style: none;\n        padding: 0;\n        margin: 0;\n        display: flex;\n        flex-direction: column;\n        gap: 10px;\n      }\n\n      .session {\n        display: flex;\n        align-items: center;\n        gap: 12px;\n        padding: 14px 16px;\n        border-radius: 14px;\n        background: var(--ion-color-light, rgba(0, 0, 0, 0.04));\n        border: 1px solid transparent;\n      }\n\n      .session--current {\n        background: rgba(45, 211, 111, 0.1);\n        border-color: rgba(45, 211, 111, 0.3);\n      }\n\n      .session__icon {\n        font-size: 26px;\n        color: var(--ion-color-dark, #1a1a1a);\n        flex-shrink: 0;\n      }\n\n      .session--current .session__icon {\n        color: var(--ion-color-success-shade, #28ba62);\n      }\n\n      .session__body {\n        display: flex;\n        flex-direction: column;\n        gap: 2px;\n        min-width: 0;\n        flex: 1;\n      }\n\n      .session__end {\n        flex-shrink: 0;\n      }\n\n      .session__badge {\n        display: inline-block;\n        padding: 4px 10px;\n        font-size: 11px;\n        font-weight: 700;\n        letter-spacing: 0.02em;\n        text-transform: uppercase;\n        color: var(--ion-color-success-shade, #28ba62);\n        background: rgba(45, 211, 111, 0.18);\n        border-radius: 999px;\n      }\n    `,\n  ],\n})\nexport class SessionListModalComponent {\n  /** Snapshot inicial — el modal mantiene su propia copia y la refresca tras revoke. */\n  @Input() set sessions(value: SessionInfo[]) {\n    this.sessionsLocal.set([...value]);\n  }\n\n  /** Título del modal (ya traducido). */\n  @Input() title = '';\n\n  /** Label del botón cerrar del header (ya traducido). */\n  @Input() closeLabel = '';\n\n  /** Label \"Esta sesión\" (en idioma activo). */\n  @Input() thisLabel = '';\n\n  /** Label del botón revoke individual. */\n  @Input() revokeLabel = '';\n\n  /**\n   * Callback que ejecuta el revoke contra el backend y retorna la lista\n   * actualizada. Pasado por `componentProps` del ModalService.\n   */\n  @Input() onRevoke?: (sessionId: string) => Promise<SessionInfo[]>;\n\n  /**\n   * Inyectado por `ModalService.open` — referencia para cerrar desde dentro.\n   * Cualquier componente abierto vía el service recibe este objeto en\n   * `componentProps`.\n   */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  close(): void {\n    this._modalRef?.dismiss(undefined, 'close');\n  }\n\n  /** Lista local mutable — refrescada después de cada revoke confirmado. */\n  protected readonly sessionsLocal = signal<SessionInfo[]>([]);\n\n  async handleRevoke(sessionId: string): Promise<void> {\n    if (!this.onRevoke) return;\n    try {\n      const updated = await this.onRevoke(sessionId);\n      this.sessionsLocal.set([...updated]);\n    } catch {\n      // El parent muestra el toast de error; modal no necesita feedback extra.\n    }\n  }\n\n  get revokeBtn(): Partial<ButtonMetadata> {\n    return {\n      text: this.revokeLabel,\n      color: 'dark',\n      fill: 'clear',\n      size: 'small',\n      type: 'button',\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  deviceIcon(s: SessionInfo): string {\n    const ua = (s.deviceInfo || '').toLowerCase();\n    const isMobile = /iphone|ipad|ipod|android|mobile/.test(ua);\n    return isMobile ? 'phone-portrait-outline' : 'laptop-outline';\n  }\n\n  formatMeta(s: SessionInfo): string {\n    const parts: string[] = [];\n    if (s.location) parts.push(s.location);\n    else if (s.ip) parts.push(s.ip);\n    if (s.createdAt) parts.push(new Date(s.createdAt).toLocaleString());\n    return parts.join(' · ');\n  }\n}\n"]}

package/esm2022/lib/components/organisms/session-list-modal/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL3Nlc3Npb24tbGlzdC1tb2RhbC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2Vzc2lvbkluZm8gfSBmcm9tICcuLi8uLi8uLi9zZXJ2aWNlcy9hdXRoL3R5cGVzJztcblxuLyoqXG4gKiBQcm9wcyBkZSBgdmFsLXNlc3Npb24tbGlzdC1tb2RhbGAgKG9yZ2FuaXNtIGNvbXBhcnRpZG8g4oCUIGxvIHJldXNhbiBsYSB2aXN0YVxuICogU2VndXJpZGFkIHkgbGEgdmlzdGEgQ3VlbnRhKS5cbiAqXG4gKiBTZSBwYXNhbiBwb3IgYGNvbXBvbmVudFByb3BzYCBkZWwgYE1vZGFsU2VydmljZS5vcGVuU2hlZXQoLi4uKWAuIFNvbiBlc2NhbGFyZXNcbiAqICsgdW4gY2FsbGJhY2sgKGBvblJldm9rZWApIOKAlCBOTyBgQE91dHB1dGAsIHBvcnF1ZSBsb3MgZXZlbnRvcyBubyBmdW5jaW9uYW4gY29uXG4gKiBgbW9kYWxDb250cm9sbGVyLmNyZWF0ZSgpYC4gRWwgY29tcG9uZW50ZSBlcyAqKmFnbsOzc3RpY28gYSBpMThuKio6IHJlY2liZSBsb3NcbiAqIGxhYmVscyB5YSB0cmFkdWNpZG9zLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNlc3Npb25MaXN0TW9kYWxQcm9wcyB7XG4gIC8qKiBTbmFwc2hvdCBpbmljaWFsIGRlIHNlc2lvbmVzIOKAlCBlbCBtb2RhbCBtYW50aWVuZSBzdSBjb3BpYSB5IGxhIHJlZnJlc2NhIHRyYXMgcmV2b2tlLiAqL1xuICBzZXNzaW9uczogU2Vzc2lvbkluZm9bXTtcbiAgLyoqIFTDrXR1bG8gZGVsIG1vZGFsICh5YSB0cmFkdWNpZG8pLiAqL1xuICB0aXRsZTogc3RyaW5nO1xuICAvKiogTGFiZWwgZGVsIGJvdMOzbiBjZXJyYXIgZGVsIGhlYWRlciAoeWEgdHJhZHVjaWRvKS4gKi9cbiAgY2xvc2VMYWJlbDogc3RyaW5nO1xuICAvKiogTGFiZWwgXCJFc3RhIHNlc2nDs25cIiAoZW4gaWRpb21hIGFjdGl2bykuICovXG4gIHRoaXNMYWJlbDogc3RyaW5nO1xuICAvKiogTGFiZWwgZGVsIGJvdMOzbiByZXZva2UgaW5kaXZpZHVhbC4gKi9cbiAgcmV2b2tlTGFiZWw6IHN0cmluZztcbiAgLyoqXG4gICAqIENhbGxiYWNrIHF1ZSBlamVjdXRhIGVsIHJldm9rZSBjb250cmEgZWwgYmFja2VuZCB5IHJldG9ybmEgbGEgbGlzdGFcbiAgICogYWN0dWFsaXphZGEgcGFyYSByZWZyZXNjYXIgZWwgbW9kYWwgZW4gc2l0aW8uXG4gICAqL1xuICBvblJldm9rZT86IChzZXNzaW9uSWQ6IHN0cmluZykgPT4gUHJvbWlzZTxTZXNzaW9uSW5mb1tdPjtcbn1cbiJdfQ==

package/esm2022/lib/services/font-size/font-size.service.mjs

@@ -39,6 +39,8 @@ export class FontSizeService {
         if (!this.isBrowser)
             return;
         document.documentElement.style.fontSize = SIZE_PX[size];
+        document.body.classList.toggle('font-large', size === FontSizeOption.LARGE);
+        document.body.classList.toggle('font-small', size === FontSizeOption.SMALL);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FontSizeService, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FontSizeService, providedIn: 'root' }); }
@@ -50,4 +52,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     type: Inject,
                     args: [PLATFORM_ID]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/version.mjs

@@ -2,5 +2,5 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export const VERSION = '2.0.983';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODMnO1xuIl19
+export const VERSION = '2.0.985';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODUnO1xuIl19