valtech-components 2.0.982 → 2.0.984

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":"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","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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJpdHkucm91dGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL29yZ2FuaXNtcy9zZWN1cml0eS12aWV3L3NlY3VyaXR5LnJvdXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUdsRTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsNEJBQTRCLENBQUMsSUFHNUM7SUFDQyxPQUFPO1FBQ0w7WUFDRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksSUFBSSxVQUFVO1lBQzlCLFNBQVMsRUFBRSxxQkFBcUI7WUFDaEMsSUFBSSxFQUFFLEVBQUUsY0FBYyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUU7U0FDdkM7S0FDRixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJvdXRlcyB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5cbmltcG9ydCB7IFNlY3VyaXR5Vmlld0NvbXBvbmVudCB9IGZyb20gJy4vc2VjdXJpdHktdmlldy5jb21wb25lbnQnO1xuaW1wb3J0IHsgU2VjdXJpdHlWaWV3Q29uZmlnIH0gZnJvbSAnLi90eXBlcyc7XG5cbi8qKlxuICogSGVscGVyIHBhcmEgbW9udGFyIGxhIHZpc3RhIFNlZ3VyaWRhZCAoYHZhbC1zZWN1cml0eS12aWV3YCkgY29tbyBydXRhIGVuIHVuYVxuICogYXBwIGRlbCBmYWN0b3J5LiBFbCBgY29uZmlnYCBzZSBwYXNhIHBvciByb3V0ZSBgZGF0YWAgKGBzZWN1cml0eUNvbmZpZ2ApIHkgZWxcbiAqIGNvbXBvbmVudGUgbG8gbGVlIGNvbW8gZmFsbGJhY2sgZGUgc3UgYEBJbnB1dCgpIGNvbmZpZ2AuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBzZXR0aW5ncy5yb3V0ZXMudHNcbiAqIGV4cG9ydCBjb25zdCBzZXR0aW5nc1JvdXRlczogUm91dGVzID0gW1xuICogICAuLi5wcm92aWRlVmFsdGVjaFNlY3VyaXR5Um91dGVzKCksXG4gKiAgIHsgcGF0aDogJ3ByZWZlcmVuY2VzJywgbG9hZENvbXBvbmVudDogKCkgPT4gLi4uIH0sXG4gKiBdO1xuICpcbiAqIC8vIGNvbiBjb25maWcgYWNvdGFkYTpcbiAqIC4uLnByb3ZpZGVWYWx0ZWNoU2VjdXJpdHlSb3V0ZXMoeyBjb25maWc6IHsgc2hvd1BvbGljaWVzOiBmYWxzZSB9IH0pLFxuICogLi4ucHJvdmlkZVZhbHRlY2hTZWN1cml0eVJvdXRlcyh7IGNvbmZpZzogeyBob21lUm91dGU6ICcvYXBwL2Rhc2hib2FyZCcgfSB9KSxcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZVZhbHRlY2hTZWN1cml0eVJvdXRlcyhvcHRzPzoge1xuICBwYXRoPzogc3RyaW5nO1xuICBjb25maWc/OiBTZWN1cml0eVZpZXdDb25maWc7XG59KTogUm91dGVzIHtcbiAgcmV0dXJuIFtcbiAgICB7XG4gICAgICBwYXRoOiBvcHRzPy5wYXRoID8/ICdzZWN1cml0eScsXG4gICAgICBjb21wb25lbnQ6IFNlY3VyaXR5Vmlld0NvbXBvbmVudCxcbiAgICAgIGRhdGE6IHsgc2VjdXJpdHlDb25maWc6IG9wdHM/LmNvbmZpZyB9LFxuICAgIH0sXG4gIF07XG59XG4iXX0=

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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/content-platform/content.service.mjs

@@ -78,7 +78,8 @@ export class ContentService {
      * @param config - Override parcial de la `ArticleMetadata` resultante.
      */
     toArticle(doc, config) {
-        return this.parser.parse(doc.body, config);
+        const locale = (doc.locale ?? 'es');
+        return this.parser.parse(doc.body, config, locale);
     }
     /** Limpia la cache de fuentes estáticas. Llamar al cambiar de locale en runtime. */
     invalidate() {
@@ -195,4 +196,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/content-platform/content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable, inject, isDevMode, signal } from '@angular/core';\nimport { Observable, catchError, forkJoin, from, map, of, switchMap, throwError } from 'rxjs';\nimport { ArticleMetadata } from '../../components/organisms/article/types';\nimport { AuthService } from '../auth/auth.service';\nimport { MarkdownArticleParserService } from '../markdown-article/markdown-article-parser.service';\nimport { VALTECH_CONTENT_CONFIG } from './config';\nimport { ContentDocument, ContentDocumentType, ContentLoadOptions } from './types';\n\n/**\n * Servicio de la plataforma de contenido (ADR-020 §2.5).\n *\n * Une dos orígenes (**híbrido**):\n *  - **Estático** — `staticSources` lazy por locale, generadas build-time.\n *  - **Backend** — DynamoDB + API (`/v2/content*`), publicación sin redeploy.\n *\n * Reglas de merge:\n *  - `list()` une ambos orígenes por `type`. Colisión de `slug` → **estático\n *    gana** (contenido curado). Ordena por `publishedAt` desc (sin fecha al final).\n *  - `load()` resuelve estático primero, con **fallback** al backend.\n *\n * Render: `toArticle(doc)` convierte `doc.body` (Markdown) a `ArticleMetadata`\n * vía el `markdown-article-parser` existente — la page hace `<val-article [props]=\"...\">`.\n *\n * Requiere `provideValtechContent({ apiUrl, appId, staticSources? })` en `main.ts`.\n * Sin provider, el servicio queda inerte (`isConfigured() === false`).\n */\n@Injectable({ providedIn: 'root' })\nexport class ContentService {\n  private readonly config = inject(VALTECH_CONTENT_CONFIG, { optional: true });\n  private readonly http = inject(HttpClient);\n  private readonly parser = inject(MarkdownArticleParserService);\n  private readonly auth = inject(AuthService, { optional: true });\n\n  /** `true` si `provideValtechContent()` fue llamado en el bootstrap. */\n  readonly isConfigured = signal(!!this.config);\n\n  /** Cache de las promesas de cada factory estática, keyed por locale. */\n  private readonly staticCache = new Map<string, Promise<ContentDocument[]>>();\n\n  constructor() {\n    if (!this.config && isDevMode()) {\n      console.warn(\n        '[valtech-components] ContentService: provideValtechContent() no está en main.ts. ' +\n          'El listado y la carga de contenido no funcionarán.'\n      );\n    }\n  }\n\n  /**\n   * Lista los documentos publicados de un `type`, uniendo estático + backend.\n   * Colisión de `slug` → estático gana. Ordenados por `publishedAt` desc.\n   *\n   * @param type - Tipo de contenido (`'blog'`, `'news'`, …).\n   * @param options - `{ locale }` (default `'es'`).\n   */\n  list(type: ContentDocumentType, options: ContentLoadOptions = {}): Observable<ContentDocument[]> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n\n    const static$ = from(this.loadStatic(locale)).pipe(\n      map(docs => docs.filter(d => d.type === type && d.status === 'published'))\n    );\n\n    const backend$ = this.listBackend(type, locale).pipe(\n      catchError(() => of<ContentDocument[]>([]))\n    );\n\n    return forkJoin({ staticDocs: static$, backendDocs: backend$ }).pipe(\n      map(({ staticDocs, backendDocs }) => this.merge(staticDocs, backendDocs))\n    );\n  }\n\n  /**\n   * Carga un documento por `slug`: estático primero, fallback al backend.\n   *\n   * @param type - Tipo de contenido.\n   * @param slug - Slug del documento.\n   * @param options - `{ locale }` (default `'es'`).\n   */\n  load(\n    type: ContentDocumentType,\n    slug: string,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n\n    return from(this.loadStatic(locale)).pipe(\n      map(docs => docs.find(d => d.type === type && d.slug === slug && d.status === 'published')),\n      switchMap(staticDoc =>\n        staticDoc\n          ? of(staticDoc)\n          : this.loadBackend(type, slug, locale).pipe(\n              catchError(() =>\n                throwError(() => new Error(`Contenido no encontrado: ${type}/${locale}/${slug}`))\n              )\n            )\n      )\n    );\n  }\n\n  /**\n   * Convierte el `body` (Markdown) de un documento en `ArticleMetadata` para\n   * renderizar con `<val-article [props]=\"...\">`. Usa el parser existente.\n   *\n   * @param doc - Documento de contenido a renderizar.\n   * @param config - Override parcial de la `ArticleMetadata` resultante.\n   */\n  toArticle(doc: ContentDocument, config?: Partial<ArticleMetadata>): ArticleMetadata {\n    return this.parser.parse(doc.body, config);\n  }\n\n  /** Limpia la cache de fuentes estáticas. Llamar al cambiar de locale en runtime. */\n  invalidate(): void {\n    this.staticCache.clear();\n  }\n\n  /**\n   * Lista los documentos publicados de la org activa del usuario autenticado.\n   *\n   * Requiere sesión activa (`AuthService.isAuthenticated()`). El interceptor de\n   * auth agrega automáticamente `Authorization: Bearer {token}` a la request.\n   *\n   * @param type  - Tipo de contenido (`'blog'`, `'news'`, …).\n   * @param options - `{ locale }` (default `'es'`).\n   * @returns Documentos de la org o `[]` si no hay config/sesión.\n   */\n  listForOrg(\n    type: ContentDocumentType,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument[]> {\n    if (!this.config?.apiUrl) return of([]);\n    if (!this.auth?.isAuthenticated()) return of([]);\n    const locale = (options.locale ?? 'es').toLowerCase();\n    return this.listBackendOrg(type, locale).pipe(catchError(() => of<ContentDocument[]>([])));\n  }\n\n  /**\n   * Carga un documento de la org activa del usuario autenticado por `slug`.\n   *\n   * Requiere sesión activa. El interceptor de auth agrega el Bearer token.\n   *\n   * @param type  - Tipo de contenido.\n   * @param slug  - Slug del documento.\n   * @param options - `{ locale }` (default `'es'`).\n   * @returns El documento o error si no se encuentra / no hay sesión.\n   */\n  loadForOrg(\n    type: ContentDocumentType,\n    slug: string,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument> {\n    if (!this.config?.apiUrl) {\n      return throwError(() => new Error('ContentService no está configurado.'));\n    }\n    if (!this.auth?.isAuthenticated()) {\n      return throwError(() => new Error('Se requiere sesión activa para cargar contenido de org.'));\n    }\n    const locale = (options.locale ?? 'es').toLowerCase();\n    return this.loadBackendOrg(type, slug, locale);\n  }\n\n  // ===========================================================================\n  // Internos\n  // ===========================================================================\n\n  /** Une estático + backend: estático gana por slug; orden por publishedAt desc. */\n  private merge(staticDocs: ContentDocument[], backendDocs: ContentDocument[]): ContentDocument[] {\n    const bySlug = new Map<string, ContentDocument>();\n    for (const doc of backendDocs) bySlug.set(doc.slug, doc);\n    // Estático gana — sobrescribe cualquier colisión del backend.\n    for (const doc of staticDocs) bySlug.set(doc.slug, doc);\n    return [...bySlug.values()].sort(this.byPublishedDesc);\n  }\n\n  /** Comparador: más reciente primero; sin `publishedAt` al final. */\n  private byPublishedDesc = (a: ContentDocument, b: ContentDocument): number => {\n    const ta = a.publishedAt ? Date.parse(a.publishedAt) : -Infinity;\n    const tb = b.publishedAt ? Date.parse(b.publishedAt) : -Infinity;\n    return tb - ta;\n  };\n\n  /** Carga (y cachea) los documentos estáticos de un locale, si hay factory. */\n  private loadStatic(locale: string): Promise<ContentDocument[]> {\n    const factory = this.config?.staticSources?.[locale];\n    if (!factory) return Promise.resolve([]);\n\n    const cached = this.staticCache.get(locale);\n    if (cached) return cached;\n\n    const promise = factory().catch(() => [] as ContentDocument[]);\n    this.staticCache.set(locale, promise);\n    return promise;\n  }\n\n  /** GET `{apiUrl}/v2/content?type=&locale=` — solo publicados. */\n  private listBackend(type: ContentDocumentType, locale: string): Observable<ContentDocument[]> {\n    if (!this.config?.apiUrl) return of([]);\n    const params = new URLSearchParams({ type, locale });\n    if (this.config.appId) params.set('appId', this.config.appId);\n    return this.http\n      .get<ContentListResponse>(`${this.config.apiUrl}/v2/content?${params}`)\n      .pipe(map(res => res?.items ?? []));\n  }\n\n  /** GET `{apiUrl}/v2/content/{type}/{locale}/{slug}` — detalle publicado. */\n  private loadBackend(\n    type: ContentDocumentType,\n    slug: string,\n    locale: string\n  ): Observable<ContentDocument> {\n    if (!this.config?.apiUrl) {\n      return throwError(() => new Error('ContentService no está configurado.'));\n    }\n    const path = `${this.config.apiUrl}/v2/content/${type}/${locale}/${encodeURIComponent(slug)}`;\n    return this.http\n      .get<ContentDetailResponse>(path)\n      .pipe(map(res => res?.item ?? (res as unknown as ContentDocument)));\n  }\n\n  /**\n   * GET `{apiUrl}/v2/content/org?type=&locale=` — publicados de la org activa.\n   * El Bearer token lo añade el interceptor de auth automáticamente.\n   */\n  private listBackendOrg(type: ContentDocumentType, locale: string): Observable<ContentDocument[]> {\n    const params = new URLSearchParams({ type, locale });\n    return this.http\n      .get<ContentListResponse>(`${this.config!.apiUrl}/v2/content/org?${params}`)\n      .pipe(map(res => res?.items ?? []));\n  }\n\n  /**\n   * GET `{apiUrl}/v2/content/org/{type}/{locale}/{slug}` — detalle de la org activa.\n   * El Bearer token lo añade el interceptor de auth automáticamente.\n   */\n  private loadBackendOrg(\n    type: ContentDocumentType,\n    slug: string,\n    locale: string\n  ): Observable<ContentDocument> {\n    const path = `${this.config!.apiUrl}/v2/content/org/${type}/${locale}/${encodeURIComponent(slug)}`;\n    return this.http\n      .get<ContentDetailResponse>(path)\n      .pipe(map(res => res?.item ?? (res as unknown as ContentDocument)));\n  }\n}\n\n/** Shape de la respuesta de listado del backend (`/v2/content`). */\ninterface ContentListResponse {\n  items?: ContentDocument[];\n  operationId?: string;\n}\n\n/** Shape de la respuesta de detalle del backend (`/v2/content/{type}/{locale}/{slug}`). */\ninterface ContentDetailResponse {\n  item?: ContentDocument;\n  operationId?: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/content-platform/content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable, inject, isDevMode, signal } from '@angular/core';\nimport { Observable, catchError, forkJoin, from, map, of, switchMap, throwError } from 'rxjs';\nimport { ArticleMetadata } from '../../components/organisms/article/types';\nimport { AuthService } from '../auth/auth.service';\nimport { MarkdownArticleParserService } from '../markdown-article/markdown-article-parser.service';\nimport { VALTECH_CONTENT_CONFIG } from './config';\nimport { ContentDocument, ContentDocumentType, ContentLoadOptions } from './types';\n\n/**\n * Servicio de la plataforma de contenido (ADR-020 §2.5).\n *\n * Une dos orígenes (**híbrido**):\n *  - **Estático** — `staticSources` lazy por locale, generadas build-time.\n *  - **Backend** — DynamoDB + API (`/v2/content*`), publicación sin redeploy.\n *\n * Reglas de merge:\n *  - `list()` une ambos orígenes por `type`. Colisión de `slug` → **estático\n *    gana** (contenido curado). Ordena por `publishedAt` desc (sin fecha al final).\n *  - `load()` resuelve estático primero, con **fallback** al backend.\n *\n * Render: `toArticle(doc)` convierte `doc.body` (Markdown) a `ArticleMetadata`\n * vía el `markdown-article-parser` existente — la page hace `<val-article [props]=\"...\">`.\n *\n * Requiere `provideValtechContent({ apiUrl, appId, staticSources? })` en `main.ts`.\n * Sin provider, el servicio queda inerte (`isConfigured() === false`).\n */\n@Injectable({ providedIn: 'root' })\nexport class ContentService {\n  private readonly config = inject(VALTECH_CONTENT_CONFIG, { optional: true });\n  private readonly http = inject(HttpClient);\n  private readonly parser = inject(MarkdownArticleParserService);\n  private readonly auth = inject(AuthService, { optional: true });\n\n  /** `true` si `provideValtechContent()` fue llamado en el bootstrap. */\n  readonly isConfigured = signal(!!this.config);\n\n  /** Cache de las promesas de cada factory estática, keyed por locale. */\n  private readonly staticCache = new Map<string, Promise<ContentDocument[]>>();\n\n  constructor() {\n    if (!this.config && isDevMode()) {\n      console.warn(\n        '[valtech-components] ContentService: provideValtechContent() no está en main.ts. ' +\n          'El listado y la carga de contenido no funcionarán.'\n      );\n    }\n  }\n\n  /**\n   * Lista los documentos publicados de un `type`, uniendo estático + backend.\n   * Colisión de `slug` → estático gana. Ordenados por `publishedAt` desc.\n   *\n   * @param type - Tipo de contenido (`'blog'`, `'news'`, …).\n   * @param options - `{ locale }` (default `'es'`).\n   */\n  list(type: ContentDocumentType, options: ContentLoadOptions = {}): Observable<ContentDocument[]> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n\n    const static$ = from(this.loadStatic(locale)).pipe(\n      map(docs => docs.filter(d => d.type === type && d.status === 'published'))\n    );\n\n    const backend$ = this.listBackend(type, locale).pipe(\n      catchError(() => of<ContentDocument[]>([]))\n    );\n\n    return forkJoin({ staticDocs: static$, backendDocs: backend$ }).pipe(\n      map(({ staticDocs, backendDocs }) => this.merge(staticDocs, backendDocs))\n    );\n  }\n\n  /**\n   * Carga un documento por `slug`: estático primero, fallback al backend.\n   *\n   * @param type - Tipo de contenido.\n   * @param slug - Slug del documento.\n   * @param options - `{ locale }` (default `'es'`).\n   */\n  load(\n    type: ContentDocumentType,\n    slug: string,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n\n    return from(this.loadStatic(locale)).pipe(\n      map(docs => docs.find(d => d.type === type && d.slug === slug && d.status === 'published')),\n      switchMap(staticDoc =>\n        staticDoc\n          ? of(staticDoc)\n          : this.loadBackend(type, slug, locale).pipe(\n              catchError(() =>\n                throwError(() => new Error(`Contenido no encontrado: ${type}/${locale}/${slug}`))\n              )\n            )\n      )\n    );\n  }\n\n  /**\n   * Convierte el `body` (Markdown) de un documento en `ArticleMetadata` para\n   * renderizar con `<val-article [props]=\"...\">`. Usa el parser existente.\n   *\n   * @param doc - Documento de contenido a renderizar.\n   * @param config - Override parcial de la `ArticleMetadata` resultante.\n   */\n  toArticle(doc: ContentDocument, config?: Partial<ArticleMetadata>): ArticleMetadata {\n    const locale = (doc.locale ?? 'es') as 'es' | 'en' | 'pt';\n    return this.parser.parse(doc.body, config, locale);\n  }\n\n  /** Limpia la cache de fuentes estáticas. Llamar al cambiar de locale en runtime. */\n  invalidate(): void {\n    this.staticCache.clear();\n  }\n\n  /**\n   * Lista los documentos publicados de la org activa del usuario autenticado.\n   *\n   * Requiere sesión activa (`AuthService.isAuthenticated()`). El interceptor de\n   * auth agrega automáticamente `Authorization: Bearer {token}` a la request.\n   *\n   * @param type  - Tipo de contenido (`'blog'`, `'news'`, …).\n   * @param options - `{ locale }` (default `'es'`).\n   * @returns Documentos de la org o `[]` si no hay config/sesión.\n   */\n  listForOrg(\n    type: ContentDocumentType,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument[]> {\n    if (!this.config?.apiUrl) return of([]);\n    if (!this.auth?.isAuthenticated()) return of([]);\n    const locale = (options.locale ?? 'es').toLowerCase();\n    return this.listBackendOrg(type, locale).pipe(catchError(() => of<ContentDocument[]>([])));\n  }\n\n  /**\n   * Carga un documento de la org activa del usuario autenticado por `slug`.\n   *\n   * Requiere sesión activa. El interceptor de auth agrega el Bearer token.\n   *\n   * @param type  - Tipo de contenido.\n   * @param slug  - Slug del documento.\n   * @param options - `{ locale }` (default `'es'`).\n   * @returns El documento o error si no se encuentra / no hay sesión.\n   */\n  loadForOrg(\n    type: ContentDocumentType,\n    slug: string,\n    options: ContentLoadOptions = {}\n  ): Observable<ContentDocument> {\n    if (!this.config?.apiUrl) {\n      return throwError(() => new Error('ContentService no está configurado.'));\n    }\n    if (!this.auth?.isAuthenticated()) {\n      return throwError(() => new Error('Se requiere sesión activa para cargar contenido de org.'));\n    }\n    const locale = (options.locale ?? 'es').toLowerCase();\n    return this.loadBackendOrg(type, slug, locale);\n  }\n\n  // ===========================================================================\n  // Internos\n  // ===========================================================================\n\n  /** Une estático + backend: estático gana por slug; orden por publishedAt desc. */\n  private merge(staticDocs: ContentDocument[], backendDocs: ContentDocument[]): ContentDocument[] {\n    const bySlug = new Map<string, ContentDocument>();\n    for (const doc of backendDocs) bySlug.set(doc.slug, doc);\n    // Estático gana — sobrescribe cualquier colisión del backend.\n    for (const doc of staticDocs) bySlug.set(doc.slug, doc);\n    return [...bySlug.values()].sort(this.byPublishedDesc);\n  }\n\n  /** Comparador: más reciente primero; sin `publishedAt` al final. */\n  private byPublishedDesc = (a: ContentDocument, b: ContentDocument): number => {\n    const ta = a.publishedAt ? Date.parse(a.publishedAt) : -Infinity;\n    const tb = b.publishedAt ? Date.parse(b.publishedAt) : -Infinity;\n    return tb - ta;\n  };\n\n  /** Carga (y cachea) los documentos estáticos de un locale, si hay factory. */\n  private loadStatic(locale: string): Promise<ContentDocument[]> {\n    const factory = this.config?.staticSources?.[locale];\n    if (!factory) return Promise.resolve([]);\n\n    const cached = this.staticCache.get(locale);\n    if (cached) return cached;\n\n    const promise = factory().catch(() => [] as ContentDocument[]);\n    this.staticCache.set(locale, promise);\n    return promise;\n  }\n\n  /** GET `{apiUrl}/v2/content?type=&locale=` — solo publicados. */\n  private listBackend(type: ContentDocumentType, locale: string): Observable<ContentDocument[]> {\n    if (!this.config?.apiUrl) return of([]);\n    const params = new URLSearchParams({ type, locale });\n    if (this.config.appId) params.set('appId', this.config.appId);\n    return this.http\n      .get<ContentListResponse>(`${this.config.apiUrl}/v2/content?${params}`)\n      .pipe(map(res => res?.items ?? []));\n  }\n\n  /** GET `{apiUrl}/v2/content/{type}/{locale}/{slug}` — detalle publicado. */\n  private loadBackend(\n    type: ContentDocumentType,\n    slug: string,\n    locale: string\n  ): Observable<ContentDocument> {\n    if (!this.config?.apiUrl) {\n      return throwError(() => new Error('ContentService no está configurado.'));\n    }\n    const path = `${this.config.apiUrl}/v2/content/${type}/${locale}/${encodeURIComponent(slug)}`;\n    return this.http\n      .get<ContentDetailResponse>(path)\n      .pipe(map(res => res?.item ?? (res as unknown as ContentDocument)));\n  }\n\n  /**\n   * GET `{apiUrl}/v2/content/org?type=&locale=` — publicados de la org activa.\n   * El Bearer token lo añade el interceptor de auth automáticamente.\n   */\n  private listBackendOrg(type: ContentDocumentType, locale: string): Observable<ContentDocument[]> {\n    const params = new URLSearchParams({ type, locale });\n    return this.http\n      .get<ContentListResponse>(`${this.config!.apiUrl}/v2/content/org?${params}`)\n      .pipe(map(res => res?.items ?? []));\n  }\n\n  /**\n   * GET `{apiUrl}/v2/content/org/{type}/{locale}/{slug}` — detalle de la org activa.\n   * El Bearer token lo añade el interceptor de auth automáticamente.\n   */\n  private loadBackendOrg(\n    type: ContentDocumentType,\n    slug: string,\n    locale: string\n  ): Observable<ContentDocument> {\n    const path = `${this.config!.apiUrl}/v2/content/org/${type}/${locale}/${encodeURIComponent(slug)}`;\n    return this.http\n      .get<ContentDetailResponse>(path)\n      .pipe(map(res => res?.item ?? (res as unknown as ContentDocument)));\n  }\n}\n\n/** Shape de la respuesta de listado del backend (`/v2/content`). */\ninterface ContentListResponse {\n  items?: ContentDocument[];\n  operationId?: string;\n}\n\n/** Shape de la respuesta de detalle del backend (`/v2/content/{type}/{locale}/{slug}`). */\ninterface ContentDetailResponse {\n  item?: ContentDocument;\n  operationId?: string;\n}\n"]}

package/esm2022/lib/services/markdown-article/markdown-article-parser.service.mjs

@@ -7,8 +7,8 @@ import * as i0 from "@angular/core";
  * `markdown-article-parser.ts` and is also usable from Node scripts (build-time generation).
  */
 export class MarkdownArticleParserService {
-    parse(markdown, config) {
-        return parseMarkdownArticle(markdown, config);
+    parse(markdown, config, locale) {
+        return parseMarkdownArticle(markdown, { ...config, locale });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MarkdownArticleParserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MarkdownArticleParserService, providedIn: 'root' }); }
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2Rvd24tYXJ0aWNsZS1wYXJzZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvbWFya2Rvd24tYXJ0aWNsZS9tYXJrZG93bi1hcnRpY2xlLXBhcnNlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBRWpFOzs7O0dBSUc7QUFFSCxNQUFNLE9BQU8sNEJBQTRCO0lBQ3ZDLEtBQUssQ0FBQyxRQUFnQixFQUFFLE1BQWlDO1FBQ3ZELE9BQU8sb0JBQW9CLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2hELENBQUM7K0dBSFUsNEJBQTRCO21IQUE1Qiw0QkFBNEIsY0FEZixNQUFNOzs0RkFDbkIsNEJBQTRCO2tCQUR4QyxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFydGljbGVNZXRhZGF0YSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvb3JnYW5pc21zL2FydGljbGUvdHlwZXMnO1xuaW1wb3J0IHsgcGFyc2VNYXJrZG93bkFydGljbGUgfSBmcm9tICcuL21hcmtkb3duLWFydGljbGUtcGFyc2VyJztcblxuLyoqXG4gKiBBbmd1bGFyIHNlcnZpY2Ugd3JhcHBlciBmb3IgdGhlIHB1cmUge0BsaW5rIHBhcnNlTWFya2Rvd25BcnRpY2xlfSBmdW5jdGlvbi5cbiAqIFByb3ZpZGVkIGluIHJvb3Qgc28gaXQgY2FuIGJlIGluamVjdGVkIGFueXdoZXJlLiBUaGUgYWN0dWFsIHBhcnNpbmcgbG9naWMgbGl2ZXMgaW5cbiAqIGBtYXJrZG93bi1hcnRpY2xlLXBhcnNlci50c2AgYW5kIGlzIGFsc28gdXNhYmxlIGZyb20gTm9kZSBzY3JpcHRzIChidWlsZC10aW1lIGdlbmVyYXRpb24pLlxuICovXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIE1hcmtkb3duQXJ0aWNsZVBhcnNlclNlcnZpY2Uge1xuICBwYXJzZShtYXJrZG93bjogc3RyaW5nLCBjb25maWc/OiBQYXJ0aWFsPEFydGljbGVNZXRhZGF0YT4pOiBBcnRpY2xlTWV0YWRhdGEge1xuICAgIHJldHVybiBwYXJzZU1hcmtkb3duQXJ0aWNsZShtYXJrZG93biwgY29uZmlnKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2Rvd24tYXJ0aWNsZS1wYXJzZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvbWFya2Rvd24tYXJ0aWNsZS9tYXJrZG93bi1hcnRpY2xlLXBhcnNlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBRWpFOzs7O0dBSUc7QUFFSCxNQUFNLE9BQU8sNEJBQTRCO0lBQ3ZDLEtBQUssQ0FDSCxRQUFnQixFQUNoQixNQUFpQyxFQUNqQyxNQUEyQjtRQUUzQixPQUFPLG9CQUFvQixDQUFDLFFBQVEsRUFBRSxFQUFFLEdBQUcsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDL0QsQ0FBQzsrR0FQVSw0QkFBNEI7bUhBQTVCLDRCQUE0QixjQURmLE1BQU07OzRGQUNuQiw0QkFBNEI7a0JBRHhDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQXJ0aWNsZU1ldGFkYXRhIH0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9vcmdhbmlzbXMvYXJ0aWNsZS90eXBlcyc7XG5pbXBvcnQgeyBwYXJzZU1hcmtkb3duQXJ0aWNsZSB9IGZyb20gJy4vbWFya2Rvd24tYXJ0aWNsZS1wYXJzZXInO1xuXG4vKipcbiAqIEFuZ3VsYXIgc2VydmljZSB3cmFwcGVyIGZvciB0aGUgcHVyZSB7QGxpbmsgcGFyc2VNYXJrZG93bkFydGljbGV9IGZ1bmN0aW9uLlxuICogUHJvdmlkZWQgaW4gcm9vdCBzbyBpdCBjYW4gYmUgaW5qZWN0ZWQgYW55d2hlcmUuIFRoZSBhY3R1YWwgcGFyc2luZyBsb2dpYyBsaXZlcyBpblxuICogYG1hcmtkb3duLWFydGljbGUtcGFyc2VyLnRzYCBhbmQgaXMgYWxzbyB1c2FibGUgZnJvbSBOb2RlIHNjcmlwdHMgKGJ1aWxkLXRpbWUgZ2VuZXJhdGlvbikuXG4gKi9cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgTWFya2Rvd25BcnRpY2xlUGFyc2VyU2VydmljZSB7XG4gIHBhcnNlKFxuICAgIG1hcmtkb3duOiBzdHJpbmcsXG4gICAgY29uZmlnPzogUGFydGlhbDxBcnRpY2xlTWV0YWRhdGE+LFxuICAgIGxvY2FsZT86ICdlcycgfCAnZW4nIHwgJ3B0J1xuICApOiBBcnRpY2xlTWV0YWRhdGEge1xuICAgIHJldHVybiBwYXJzZU1hcmtkb3duQXJ0aWNsZShtYXJrZG93biwgeyAuLi5jb25maWcsIGxvY2FsZSB9KTtcbiAgfVxufVxuIl19

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.982';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODInO1xuIl19
+export const VERSION = '2.0.984';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODQnO1xuIl19