valtech-components 2.0.1024 → 2.0.1026

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

@@ -56,11 +56,11 @@ export const ORGANIZATION_VIEW_I18N = {
         importOpen: 'Importar',
         apiKeysOpen: 'Gestionar',
         apiKeysSectionTitle: 'Integraciones (API Keys)',
-        apiKeysSectionHint: 'También puedes operar tu organización vía API: crea una Client API Key org-scopeada para integraciones máquina-a-máquina (por ejemplo, dar de alta miembros en masa desde tu propio sistema).',
+        apiKeysSectionHint: 'Conecta tus sistemas externos a esta organización vía API Key.',
         apiKeysMoreInfo: 'Más información',
         apiKeysInfoTitle: 'Integraciones por API',
-        apiKeysInfoSubtitle: 'Opera tu organización máquina-a-máquina',
-        apiKeysInfoContent: 'Una API Key te permite operar tu organización desde tus propios sistemas, sin entrar a la app: dar de alta usuarios, asignar roles, leer datos y automatizar flujos.\n\nCada key es org-scopeada y lleva solo los permisos que le asignes — concede el mínimo necesario. Puedes revocarla en cualquier momento.\n\nEl secreto se muestra una sola vez al crearla: guárdalo en un lugar seguro. Si lo pierdes, genera una nueva key y revoca la anterior.',
+        apiKeysInfoSubtitle: '¿Qué puedes hacer con una API Key?',
+        apiKeysInfoContent: 'Una API Key te permite automatizar operaciones en tu organización desde tus propios sistemas, sin abrir la app. Es ideal para integraciones máquina-a-máquina: sincronizar usuarios desde tu ERP, asignar roles en masa o consultar datos desde tus reportes internos.\n\nCon una key puedes dar de alta y gestionar miembros, asignar roles y permisos, leer datos de la organización y conectar flujos de trabajo existentes.\n\nCada key lleva solo los permisos que tú le asignes — concede el mínimo necesario y revócala en cualquier momento desde la sección Integraciones.\n\nImportante: el secreto se muestra una sola vez al crear la key. Guárdalo en un lugar seguro (gestor de secretos, variable de entorno). Si lo pierdes, genera una nueva key y revoca la anterior.',
         apiKeysInfoClose: 'Cerrar',
         orgsMoreInfo: 'Aprender más sobre organizaciones',
         orgsInfoTitle: '¿Qué son las organizaciones?',
@@ -139,11 +139,11 @@ export const ORGANIZATION_VIEW_I18N = {
         importOpen: 'Import',
         apiKeysOpen: 'Manage',
         apiKeysSectionTitle: 'Integrations (API Keys)',
-        apiKeysSectionHint: 'You can also operate your organization via API: create an org-scoped Client API Key for machine-to-machine integrations (for example, bulk-provisioning members from your own system).',
+        apiKeysSectionHint: 'Connect your external systems to this organization via API Key.',
         apiKeysMoreInfo: 'More information',
         apiKeysInfoTitle: 'API integrations',
-        apiKeysInfoSubtitle: 'Operate your organization machine-to-machine',
-        apiKeysInfoContent: 'An API Key lets you operate your organization from your own systems, without opening the app: provision users, assign roles, read data, and automate flows.\n\nEach key is org-scoped and carries only the permissions you assign — grant the minimum needed. You can revoke it at any time.\n\nThe secret is shown only once at creation: store it somewhere safe. If you lose it, create a new key and revoke the old one.',
+        apiKeysInfoSubtitle: 'What can you do with an API Key?',
+        apiKeysInfoContent: 'An API Key lets you automate operations in your organization from your own systems, without opening the app. It is ideal for machine-to-machine integrations: sync users from your ERP, bulk-assign roles, or query data for your internal reports.\n\nWith a key you can provision and manage members, assign roles and permissions, read organization data, and connect existing workflows.\n\nEach key carries only the permissions you assign — grant the minimum needed and revoke it at any time from the Integrations section.\n\nImportant: the secret is shown only once when the key is created. Store it somewhere safe (secret manager, environment variable). If you lose it, create a new key and revoke the old one.',
         apiKeysInfoClose: 'Close',
         orgsMoreInfo: 'Learn more about organizations',
         orgsInfoTitle: 'What are organizations?',
@@ -173,4 +173,4 @@ export const ORGANIZATION_VIEW_I18N = {
         membersShowMore: 'Show more',
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"organization-view.i18n.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/organization-view/organization-view.i18n.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAqB;IACtD,EAAE,EAAE;QACF,SAAS,EAAE,cAAc;QACzB,eAAe,EAAE,iCAAiC;QAClD,SAAS,EAAE,aAAa;QACxB,QAAQ,EAAE,QAAQ;QAClB,eAAe,EAAE,aAAa;QAC9B,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,QAAQ;QACjB,OAAO,EAAE,SAAS;QAClB,SAAS,EAAE,UAAU;QACrB,YAAY,EAAE,UAAU;QACxB,YAAY,EAAE,mBAAmB;QACjC,WAAW,EAAE,OAAO;QACpB,WAAW,EAAE,SAAS;QACtB,WAAW,EAAE,oBAAoB;QACjC,UAAU,EAAE,KAAK;QACjB,SAAS,EAAE,SAAS;QACpB,aAAa,EAAE,qBAAqB;QACpC,WAAW,EAAE,kCAAkC;QAC/C,YAAY,EAAE,qCAAqC;QACnD,UAAU,EAAE,0BAA0B;QACtC,SAAS,EAAE,8CAA8C;QACzD,QAAQ,EAAE,OAAO;QACjB,cAAc,EAAE,8DAA8D;QAC9E,YAAY,EAAE,4BAA4B;QAC1C,QAAQ,EAAE,UAAU;QACpB,OAAO,EAAE,KAAK;QACd,cAAc,EAAE,SAAS;QACzB,WAAW,EAAE,2BAA2B;QACxC,YAAY,EAAE,gCAAgC;QAC9C,UAAU,EAAE,mCAAmC;QAC/C,YAAY,EAAE,cAAc;QAC5B,WAAW,EAAE,0CAA0C;QACvD,KAAK,EAAE,YAAY;QACnB,SAAS,EAAE,uCAAuC;QAClD,UAAU,EAAE,qCAAqC;QACjD,aAAa,EAAE,sBAAsB;QACrC,YAAY,EAAE,qEAAqE;QACnF,cAAc,EAAE,+BAA+B;QAC/C,WAAW,EAAE,YAAY;QACzB,eAAe,EAAE,0EAA0E;QAC3F,eAAe,EAAE,wBAAwB;QACzC,aAAa,EAAE,qCAAqC;QACpD,cAAc,EAAE,4BAA4B;QAC5C,aAAa,EAAE,+CAA+C;QAC9D,UAAU,EAAE,SAAS;QACrB,UAAU,EAAE,UAAU;QACtB,WAAW,EAAE,WAAW;QACxB,mBAAmB,EAAE,0BAA0B;QAC/C,kBAAkB,EAChB,+LAA+L;QACjM,eAAe,EAAE,iBAAiB;QAClC,gBAAgB,EAAE,uBAAuB;QACzC,mBAAmB,EAAE,yCAAyC;QAC9D,kBAAkB,EAChB,0bAA0b;QAC5b,gBAAgB,EAAE,QAAQ;QAC1B,YAAY,EAAE,mCAAmC;QACjD,aAAa,EAAE,8BAA8B;QAC7C,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,QAAQ;QACvB,eAAe,EACb,2ZAA2Z;QAC7Z,aAAa,EAAE,aAAa;QAC5B,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,QAAQ;QACpB,SAAS,EAAE,OAAO;QAClB,cAAc,EAAE,aAAa;QAC7B,iBAAiB,EAAE,kBAAkB;QACrC,SAAS,EACP,oIAAoI;QACtI,cAAc,EAAE,sBAAsB;QACtC,gBAAgB,EAAE,SAAS;QAC3B,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,UAAU;QACrB,aAAa,EAAE,YAAY;QAC3B,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,YAAY;QAC3B,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,UAAU;QACrB,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,UAAU;QACtB,UAAU,EAAE,WAAW;QACvB,eAAe,EAAE,SAAS;KAC3B;IACD,EAAE,EAAE;QACF,SAAS,EAAE,cAAc;QACzB,eAAe,EAAE,iCAAiC;QAClD,SAAS,EAAE,aAAa;QACxB,QAAQ,EAAE,MAAM;QAChB,eAAe,EAAE,aAAa;QAC9B,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,MAAM;QACf,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,QAAQ;QACnB,YAAY,EAAE,SAAS;QACvB,YAAY,EAAE,iBAAiB;QAC/B,WAAW,EAAE,OAAO;QACpB,WAAW,EAAE,QAAQ;QACrB,WAAW,EAAE,eAAe;QAC5B,UAAU,EAAE,MAAM;QAClB,SAAS,EAAE,QAAQ;QACnB,aAAa,EAAE,kBAAkB;QACjC,WAAW,EAAE,4BAA4B;QACzC,YAAY,EAAE,yBAAyB;QACvC,UAAU,EAAE,oBAAoB;QAChC,SAAS,EAAE,4CAA4C;QACvD,QAAQ,EAAE,OAAO;QACjB,cAAc,EAAE,uDAAuD;QACvE,YAAY,EAAE,0BAA0B;QACxC,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,KAAK;QACd,cAAc,EAAE,YAAY;QAC5B,WAAW,EAAE,uBAAuB;QACpC,YAAY,EAAE,iCAAiC;QAC/C,UAAU,EAAE,6BAA6B;QACzC,YAAY,EAAE,eAAe;QAC7B,WAAW,EAAE,sCAAsC;QACnD,KAAK,EAAE,OAAO;QACd,SAAS,EAAE,mCAAmC;QAC9C,UAAU,EAAE,oCAAoC;QAChD,aAAa,EAAE,oBAAoB;QACnC,YAAY,EAAE,6DAA6D;QAC3E,cAAc,EAAE,kBAAkB;QAClC,WAAW,EAAE,UAAU;QACvB,eAAe,EAAE,kEAAkE;QACnF,eAAe,EAAE,wBAAwB;QACzC,aAAa,EAAE,+BAA+B;QAC9C,cAAc,EAAE,sBAAsB;QACtC,aAAa,EAAE,yCAAyC;QACxD,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,WAAW,EAAE,QAAQ;QACrB,mBAAmB,EAAE,yBAAyB;QAC9C,kBAAkB,EAChB,wLAAwL;QAC1L,eAAe,EAAE,kBAAkB;QACnC,gBAAgB,EAAE,kBAAkB;QACpC,mBAAmB,EAAE,8CAA8C;QACnE,kBAAkB,EAChB,8ZAA8Z;QACha,gBAAgB,EAAE,OAAO;QACzB,YAAY,EAAE,gCAAgC;QAC9C,aAAa,EAAE,yBAAyB;QACxC,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,OAAO;QACtB,eAAe,EACb,sYAAsY;QACxY,aAAa,EAAE,aAAa;QAC5B,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,SAAS,EAAE,OAAO;QAClB,cAAc,EAAE,aAAa;QAC7B,iBAAiB,EAAE,qBAAqB;QACxC,SAAS,EACP,8HAA8H;QAChI,cAAc,EAAE,0BAA0B;QAC1C,gBAAgB,EAAE,QAAQ;QAC1B,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,WAAW;QAC1B,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,WAAW;QAC1B,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,OAAO;QAClB,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,eAAe,EAAE,WAAW;KAC7B;CACF,CAAC","sourcesContent":["import { LanguagesContent } from '../../../services/i18n/types';\n\n/**\n * Defaults i18n (es/en) embebidos en `val-organization-view`. Auto-registrados en\n * el constructor del componente si el consumer no proveyó el namespace\n * (`Settings.Organization` por default). SOLO incluye las keys que la vista usa.\n *\n * Portado de `ORG_I18N_CONTENT` (showcase) bajo el proceso de ADR-021.\n */\nexport const ORGANIZATION_VIEW_I18N: LanguagesContent = {\n  es: {\n    pageTitle: 'Organización',\n    pageDescription: 'Gestiona tu organización activa',\n    infoTitle: 'Información',\n    infoName: 'Nombre',\n    infoDescription: 'Descripción',\n    infoPlan: 'Plan',\n    infoType: 'Tipo',\n    editCta: 'Editar',\n    saveCta: 'Guardar',\n    cancelCta: 'Cancelar',\n    membersTitle: 'Miembros',\n    membersEmpty: 'Sin miembros aún.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invitar',\n    inviteEmail: 'Correo electrónico',\n    inviteRole: 'Rol',\n    inviteCta: 'Invitar',\n    inviteSuccess: 'Invitación enviada.',\n    inviteError: 'No se pudo enviar la invitación.',\n    membersError: 'No se pudieron cargar los miembros.',\n    leaveTitle: 'Salir de la organización',\n    leaveHint: 'Dejarás de tener acceso a esta organización.',\n    leaveCta: 'Salir',\n    leaveOwnerHint: 'Eres el propietario. Transfiere la propiedad antes de salir.',\n    leaveConfirm: '¿Salir de la organización?',\n    planFree: 'Gratuito',\n    planPro: 'Pro',\n    planEnterprise: 'Empresa',\n    saveSuccess: 'Organización actualizada.',\n    leaveSuccess: 'Has salido de la organización.',\n    errorTitle: 'No se pudo cargar la organización',\n    offlineTitle: 'Sin conexión',\n    offlineHint: 'Verifica tu conexión e intenta de nuevo.',\n    retry: 'Reintentar',\n    saveError: 'No se pudo guardar. Intenta de nuevo.',\n    leaveError: 'No se pudo salir. Intenta de nuevo.',\n    transferTitle: 'Transferir propiedad',\n    transferHint: 'Elige un miembro para transferirle la propiedad de la organización.',\n    transferSelect: 'Seleccionar nuevo propietario',\n    transferCta: 'Transferir',\n    transferConfirm: '¿Transferir la propiedad a este miembro? Perderás el rol de propietario.',\n    transferSuccess: 'Propiedad transferida.',\n    transferError: 'No se pudo transferir la propiedad.',\n    inviteCtaTitle: '¿Deseas agregar a alguien?',\n    inviteCtaHint: 'Invita a usuarios a unirse a tu organización.',\n    inviteOpen: 'Invitar',\n    importOpen: 'Importar',\n    apiKeysOpen: 'Gestionar',\n    apiKeysSectionTitle: 'Integraciones (API Keys)',\n    apiKeysSectionHint:\n      'También puedes operar tu organización vía API: crea una Client API Key org-scopeada para integraciones máquina-a-máquina (por ejemplo, dar de alta miembros en masa desde tu propio sistema).',\n    apiKeysMoreInfo: 'Más información',\n    apiKeysInfoTitle: 'Integraciones por API',\n    apiKeysInfoSubtitle: 'Opera tu organización máquina-a-máquina',\n    apiKeysInfoContent:\n      'Una API Key te permite operar tu organización desde tus propios sistemas, sin entrar a la app: dar de alta usuarios, asignar roles, leer datos y automatizar flujos.\\n\\nCada key es org-scopeada y lleva solo los permisos que le asignes — concede el mínimo necesario. Puedes revocarla en cualquier momento.\\n\\nEl secreto se muestra una sola vez al crearla: guárdalo en un lugar seguro. Si lo pierdes, genera una nueva key y revoca la anterior.',\n    apiKeysInfoClose: 'Cerrar',\n    orgsMoreInfo: 'Aprender más sobre organizaciones',\n    orgsInfoTitle: '¿Qué son las organizaciones?',\n    orgsInfoSubtitle: 'Todo lo que necesitas saber',\n    orgsInfoClose: 'Cerrar',\n    orgsInfoContent:\n      'Las organizaciones te permiten separar tus proyectos y datos por empresa, equipo o contexto. Puedes pertenecer a varias organizaciones y cambiar entre ellas en cualquier momento.\\n\\nCada organización tiene sus propios miembros, roles y permisos. La organización activa determina qué datos ves y qué acciones puedes realizar.\\n\\nPuedes crear una organización nueva o unirte a una existente mediante invitación.',\n    viewMemberCta: 'Ver miembro',\n    roleViewer: 'Visor',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles y permisos',\n    rolesHint:\n      'Tu organización tiene roles que controlan lo que cada miembro puede ver y hacer. Cada rol lleva un conjunto de permisos asociados.',\n    rolesViewPerms: 'Ver roles y permisos',\n    rolesSystemBadge: 'Sistema',\n    permAll: 'Todo',\n    permUsers: 'Usuarios',\n    permDocuments: 'Documentos',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Plantillas',\n    permRead: 'Leer',\n    permWrite: 'Escribir',\n    permCreate: 'Crear',\n    permDelete: 'Eliminar',\n    permManage: 'Gestionar',\n    membersShowMore: 'Ver más',\n  },\n  en: {\n    pageTitle: 'Organization',\n    pageDescription: 'Manage your active organization',\n    infoTitle: 'Information',\n    infoName: 'Name',\n    infoDescription: 'Description',\n    infoPlan: 'Plan',\n    infoType: 'Type',\n    editCta: 'Edit',\n    saveCta: 'Save',\n    cancelCta: 'Cancel',\n    membersTitle: 'Members',\n    membersEmpty: 'No members yet.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invite',\n    inviteEmail: 'Email address',\n    inviteRole: 'Role',\n    inviteCta: 'Invite',\n    inviteSuccess: 'Invitation sent.',\n    inviteError: 'Could not send invitation.',\n    membersError: 'Could not load members.',\n    leaveTitle: 'Leave organization',\n    leaveHint: 'You will lose access to this organization.',\n    leaveCta: 'Leave',\n    leaveOwnerHint: 'You are the owner. Transfer ownership before leaving.',\n    leaveConfirm: 'Leave this organization?',\n    planFree: 'Free',\n    planPro: 'Pro',\n    planEnterprise: 'Enterprise',\n    saveSuccess: 'Organization updated.',\n    leaveSuccess: 'You have left the organization.',\n    errorTitle: 'Could not load organization',\n    offlineTitle: 'No connection',\n    offlineHint: 'Check your connection and try again.',\n    retry: 'Retry',\n    saveError: 'Could not save. Please try again.',\n    leaveError: 'Could not leave. Please try again.',\n    transferTitle: 'Transfer ownership',\n    transferHint: 'Choose a member to transfer ownership of this organization.',\n    transferSelect: 'Select new owner',\n    transferCta: 'Transfer',\n    transferConfirm: 'Transfer ownership to this member? You will lose the owner role.',\n    transferSuccess: 'Ownership transferred.',\n    transferError: 'Could not transfer ownership.',\n    inviteCtaTitle: 'Want to add someone?',\n    inviteCtaHint: 'Invite users to join your organization.',\n    inviteOpen: 'Invite',\n    importOpen: 'Import',\n    apiKeysOpen: 'Manage',\n    apiKeysSectionTitle: 'Integrations (API Keys)',\n    apiKeysSectionHint:\n      'You can also operate your organization via API: create an org-scoped Client API Key for machine-to-machine integrations (for example, bulk-provisioning members from your own system).',\n    apiKeysMoreInfo: 'More information',\n    apiKeysInfoTitle: 'API integrations',\n    apiKeysInfoSubtitle: 'Operate your organization machine-to-machine',\n    apiKeysInfoContent:\n      'An API Key lets you operate your organization from your own systems, without opening the app: provision users, assign roles, read data, and automate flows.\\n\\nEach key is org-scoped and carries only the permissions you assign — grant the minimum needed. You can revoke it at any time.\\n\\nThe secret is shown only once at creation: store it somewhere safe. If you lose it, create a new key and revoke the old one.',\n    apiKeysInfoClose: 'Close',\n    orgsMoreInfo: 'Learn more about organizations',\n    orgsInfoTitle: 'What are organizations?',\n    orgsInfoSubtitle: 'Everything you need to know',\n    orgsInfoClose: 'Close',\n    orgsInfoContent:\n      'Organizations let you separate your projects and data by company, team, or context. You can belong to multiple organizations and switch between them at any time.\\n\\nEach organization has its own members, roles, and permissions. The active organization determines what data you see and what actions you can take.\\n\\nYou can create a new organization or join an existing one via invitation.',\n    viewMemberCta: 'View member',\n    roleViewer: 'Viewer',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles & permissions',\n    rolesHint:\n      'Your organization has roles that control what each member can see and do. Each role carries a set of associated permissions.',\n    rolesViewPerms: 'View roles & permissions',\n    rolesSystemBadge: 'System',\n    permAll: 'All',\n    permUsers: 'Users',\n    permDocuments: 'Documents',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Templates',\n    permRead: 'Read',\n    permWrite: 'Write',\n    permCreate: 'Create',\n    permDelete: 'Delete',\n    permManage: 'Manage',\n    membersShowMore: 'Show more',\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"organization-view.i18n.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/organization-view/organization-view.i18n.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAqB;IACtD,EAAE,EAAE;QACF,SAAS,EAAE,cAAc;QACzB,eAAe,EAAE,iCAAiC;QAClD,SAAS,EAAE,aAAa;QACxB,QAAQ,EAAE,QAAQ;QAClB,eAAe,EAAE,aAAa;QAC9B,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,QAAQ;QACjB,OAAO,EAAE,SAAS;QAClB,SAAS,EAAE,UAAU;QACrB,YAAY,EAAE,UAAU;QACxB,YAAY,EAAE,mBAAmB;QACjC,WAAW,EAAE,OAAO;QACpB,WAAW,EAAE,SAAS;QACtB,WAAW,EAAE,oBAAoB;QACjC,UAAU,EAAE,KAAK;QACjB,SAAS,EAAE,SAAS;QACpB,aAAa,EAAE,qBAAqB;QACpC,WAAW,EAAE,kCAAkC;QAC/C,YAAY,EAAE,qCAAqC;QACnD,UAAU,EAAE,0BAA0B;QACtC,SAAS,EAAE,8CAA8C;QACzD,QAAQ,EAAE,OAAO;QACjB,cAAc,EAAE,8DAA8D;QAC9E,YAAY,EAAE,4BAA4B;QAC1C,QAAQ,EAAE,UAAU;QACpB,OAAO,EAAE,KAAK;QACd,cAAc,EAAE,SAAS;QACzB,WAAW,EAAE,2BAA2B;QACxC,YAAY,EAAE,gCAAgC;QAC9C,UAAU,EAAE,mCAAmC;QAC/C,YAAY,EAAE,cAAc;QAC5B,WAAW,EAAE,0CAA0C;QACvD,KAAK,EAAE,YAAY;QACnB,SAAS,EAAE,uCAAuC;QAClD,UAAU,EAAE,qCAAqC;QACjD,aAAa,EAAE,sBAAsB;QACrC,YAAY,EAAE,qEAAqE;QACnF,cAAc,EAAE,+BAA+B;QAC/C,WAAW,EAAE,YAAY;QACzB,eAAe,EAAE,0EAA0E;QAC3F,eAAe,EAAE,wBAAwB;QACzC,aAAa,EAAE,qCAAqC;QACpD,cAAc,EAAE,4BAA4B;QAC5C,aAAa,EAAE,+CAA+C;QAC9D,UAAU,EAAE,SAAS;QACrB,UAAU,EAAE,UAAU;QACtB,WAAW,EAAE,WAAW;QACxB,mBAAmB,EAAE,0BAA0B;QAC/C,kBAAkB,EAAE,gEAAgE;QACpF,eAAe,EAAE,iBAAiB;QAClC,gBAAgB,EAAE,uBAAuB;QACzC,mBAAmB,EAAE,oCAAoC;QACzD,kBAAkB,EAChB,yvBAAyvB;QAC3vB,gBAAgB,EAAE,QAAQ;QAC1B,YAAY,EAAE,mCAAmC;QACjD,aAAa,EAAE,8BAA8B;QAC7C,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,QAAQ;QACvB,eAAe,EACb,2ZAA2Z;QAC7Z,aAAa,EAAE,aAAa;QAC5B,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,QAAQ;QACpB,SAAS,EAAE,OAAO;QAClB,cAAc,EAAE,aAAa;QAC7B,iBAAiB,EAAE,kBAAkB;QACrC,SAAS,EACP,oIAAoI;QACtI,cAAc,EAAE,sBAAsB;QACtC,gBAAgB,EAAE,SAAS;QAC3B,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,UAAU;QACrB,aAAa,EAAE,YAAY;QAC3B,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,YAAY;QAC3B,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,UAAU;QACrB,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,UAAU;QACtB,UAAU,EAAE,WAAW;QACvB,eAAe,EAAE,SAAS;KAC3B;IACD,EAAE,EAAE;QACF,SAAS,EAAE,cAAc;QACzB,eAAe,EAAE,iCAAiC;QAClD,SAAS,EAAE,aAAa;QACxB,QAAQ,EAAE,MAAM;QAChB,eAAe,EAAE,aAAa;QAC9B,QAAQ,EAAE,MAAM;QAChB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,MAAM;QACf,OAAO,EAAE,MAAM;QACf,SAAS,EAAE,QAAQ;QACnB,YAAY,EAAE,SAAS;QACvB,YAAY,EAAE,iBAAiB;QAC/B,WAAW,EAAE,OAAO;QACpB,WAAW,EAAE,QAAQ;QACrB,WAAW,EAAE,eAAe;QAC5B,UAAU,EAAE,MAAM;QAClB,SAAS,EAAE,QAAQ;QACnB,aAAa,EAAE,kBAAkB;QACjC,WAAW,EAAE,4BAA4B;QACzC,YAAY,EAAE,yBAAyB;QACvC,UAAU,EAAE,oBAAoB;QAChC,SAAS,EAAE,4CAA4C;QACvD,QAAQ,EAAE,OAAO;QACjB,cAAc,EAAE,uDAAuD;QACvE,YAAY,EAAE,0BAA0B;QACxC,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,KAAK;QACd,cAAc,EAAE,YAAY;QAC5B,WAAW,EAAE,uBAAuB;QACpC,YAAY,EAAE,iCAAiC;QAC/C,UAAU,EAAE,6BAA6B;QACzC,YAAY,EAAE,eAAe;QAC7B,WAAW,EAAE,sCAAsC;QACnD,KAAK,EAAE,OAAO;QACd,SAAS,EAAE,mCAAmC;QAC9C,UAAU,EAAE,oCAAoC;QAChD,aAAa,EAAE,oBAAoB;QACnC,YAAY,EAAE,6DAA6D;QAC3E,cAAc,EAAE,kBAAkB;QAClC,WAAW,EAAE,UAAU;QACvB,eAAe,EAAE,kEAAkE;QACnF,eAAe,EAAE,wBAAwB;QACzC,aAAa,EAAE,+BAA+B;QAC9C,cAAc,EAAE,sBAAsB;QACtC,aAAa,EAAE,yCAAyC;QACxD,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,WAAW,EAAE,QAAQ;QACrB,mBAAmB,EAAE,yBAAyB;QAC9C,kBAAkB,EAAE,iEAAiE;QACrF,eAAe,EAAE,kBAAkB;QACnC,gBAAgB,EAAE,kBAAkB;QACpC,mBAAmB,EAAE,kCAAkC;QACvD,kBAAkB,EAChB,qsBAAqsB;QACvsB,gBAAgB,EAAE,OAAO;QACzB,YAAY,EAAE,gCAAgC;QAC9C,aAAa,EAAE,yBAAyB;QACxC,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,OAAO;QACtB,eAAe,EACb,sYAAsY;QACxY,aAAa,EAAE,aAAa;QAC5B,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,SAAS,EAAE,OAAO;QAClB,cAAc,EAAE,aAAa;QAC7B,iBAAiB,EAAE,qBAAqB;QACxC,SAAS,EACP,8HAA8H;QAChI,cAAc,EAAE,0BAA0B;QAC1C,gBAAgB,EAAE,QAAQ;QAC1B,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,WAAW;QAC1B,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,WAAW;QAC1B,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,OAAO;QAClB,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;QACpB,eAAe,EAAE,WAAW;KAC7B;CACF,CAAC","sourcesContent":["import { LanguagesContent } from '../../../services/i18n/types';\n\n/**\n * Defaults i18n (es/en) embebidos en `val-organization-view`. Auto-registrados en\n * el constructor del componente si el consumer no proveyó el namespace\n * (`Settings.Organization` por default). SOLO incluye las keys que la vista usa.\n *\n * Portado de `ORG_I18N_CONTENT` (showcase) bajo el proceso de ADR-021.\n */\nexport const ORGANIZATION_VIEW_I18N: LanguagesContent = {\n  es: {\n    pageTitle: 'Organización',\n    pageDescription: 'Gestiona tu organización activa',\n    infoTitle: 'Información',\n    infoName: 'Nombre',\n    infoDescription: 'Descripción',\n    infoPlan: 'Plan',\n    infoType: 'Tipo',\n    editCta: 'Editar',\n    saveCta: 'Guardar',\n    cancelCta: 'Cancelar',\n    membersTitle: 'Miembros',\n    membersEmpty: 'Sin miembros aún.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invitar',\n    inviteEmail: 'Correo electrónico',\n    inviteRole: 'Rol',\n    inviteCta: 'Invitar',\n    inviteSuccess: 'Invitación enviada.',\n    inviteError: 'No se pudo enviar la invitación.',\n    membersError: 'No se pudieron cargar los miembros.',\n    leaveTitle: 'Salir de la organización',\n    leaveHint: 'Dejarás de tener acceso a esta organización.',\n    leaveCta: 'Salir',\n    leaveOwnerHint: 'Eres el propietario. Transfiere la propiedad antes de salir.',\n    leaveConfirm: '¿Salir de la organización?',\n    planFree: 'Gratuito',\n    planPro: 'Pro',\n    planEnterprise: 'Empresa',\n    saveSuccess: 'Organización actualizada.',\n    leaveSuccess: 'Has salido de la organización.',\n    errorTitle: 'No se pudo cargar la organización',\n    offlineTitle: 'Sin conexión',\n    offlineHint: 'Verifica tu conexión e intenta de nuevo.',\n    retry: 'Reintentar',\n    saveError: 'No se pudo guardar. Intenta de nuevo.',\n    leaveError: 'No se pudo salir. Intenta de nuevo.',\n    transferTitle: 'Transferir propiedad',\n    transferHint: 'Elige un miembro para transferirle la propiedad de la organización.',\n    transferSelect: 'Seleccionar nuevo propietario',\n    transferCta: 'Transferir',\n    transferConfirm: '¿Transferir la propiedad a este miembro? Perderás el rol de propietario.',\n    transferSuccess: 'Propiedad transferida.',\n    transferError: 'No se pudo transferir la propiedad.',\n    inviteCtaTitle: '¿Deseas agregar a alguien?',\n    inviteCtaHint: 'Invita a usuarios a unirse a tu organización.',\n    inviteOpen: 'Invitar',\n    importOpen: 'Importar',\n    apiKeysOpen: 'Gestionar',\n    apiKeysSectionTitle: 'Integraciones (API Keys)',\n    apiKeysSectionHint: 'Conecta tus sistemas externos a esta organización vía API Key.',\n    apiKeysMoreInfo: 'Más información',\n    apiKeysInfoTitle: 'Integraciones por API',\n    apiKeysInfoSubtitle: '¿Qué puedes hacer con una API Key?',\n    apiKeysInfoContent:\n      'Una API Key te permite automatizar operaciones en tu organización desde tus propios sistemas, sin abrir la app. Es ideal para integraciones máquina-a-máquina: sincronizar usuarios desde tu ERP, asignar roles en masa o consultar datos desde tus reportes internos.\\n\\nCon una key puedes dar de alta y gestionar miembros, asignar roles y permisos, leer datos de la organización y conectar flujos de trabajo existentes.\\n\\nCada key lleva solo los permisos que tú le asignes — concede el mínimo necesario y revócala en cualquier momento desde la sección Integraciones.\\n\\nImportante: el secreto se muestra una sola vez al crear la key. Guárdalo en un lugar seguro (gestor de secretos, variable de entorno). Si lo pierdes, genera una nueva key y revoca la anterior.',\n    apiKeysInfoClose: 'Cerrar',\n    orgsMoreInfo: 'Aprender más sobre organizaciones',\n    orgsInfoTitle: '¿Qué son las organizaciones?',\n    orgsInfoSubtitle: 'Todo lo que necesitas saber',\n    orgsInfoClose: 'Cerrar',\n    orgsInfoContent:\n      'Las organizaciones te permiten separar tus proyectos y datos por empresa, equipo o contexto. Puedes pertenecer a varias organizaciones y cambiar entre ellas en cualquier momento.\\n\\nCada organización tiene sus propios miembros, roles y permisos. La organización activa determina qué datos ves y qué acciones puedes realizar.\\n\\nPuedes crear una organización nueva o unirte a una existente mediante invitación.',\n    viewMemberCta: 'Ver miembro',\n    roleViewer: 'Visor',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles y permisos',\n    rolesHint:\n      'Tu organización tiene roles que controlan lo que cada miembro puede ver y hacer. Cada rol lleva un conjunto de permisos asociados.',\n    rolesViewPerms: 'Ver roles y permisos',\n    rolesSystemBadge: 'Sistema',\n    permAll: 'Todo',\n    permUsers: 'Usuarios',\n    permDocuments: 'Documentos',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Plantillas',\n    permRead: 'Leer',\n    permWrite: 'Escribir',\n    permCreate: 'Crear',\n    permDelete: 'Eliminar',\n    permManage: 'Gestionar',\n    membersShowMore: 'Ver más',\n  },\n  en: {\n    pageTitle: 'Organization',\n    pageDescription: 'Manage your active organization',\n    infoTitle: 'Information',\n    infoName: 'Name',\n    infoDescription: 'Description',\n    infoPlan: 'Plan',\n    infoType: 'Type',\n    editCta: 'Edit',\n    saveCta: 'Save',\n    cancelCta: 'Cancel',\n    membersTitle: 'Members',\n    membersEmpty: 'No members yet.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invite',\n    inviteEmail: 'Email address',\n    inviteRole: 'Role',\n    inviteCta: 'Invite',\n    inviteSuccess: 'Invitation sent.',\n    inviteError: 'Could not send invitation.',\n    membersError: 'Could not load members.',\n    leaveTitle: 'Leave organization',\n    leaveHint: 'You will lose access to this organization.',\n    leaveCta: 'Leave',\n    leaveOwnerHint: 'You are the owner. Transfer ownership before leaving.',\n    leaveConfirm: 'Leave this organization?',\n    planFree: 'Free',\n    planPro: 'Pro',\n    planEnterprise: 'Enterprise',\n    saveSuccess: 'Organization updated.',\n    leaveSuccess: 'You have left the organization.',\n    errorTitle: 'Could not load organization',\n    offlineTitle: 'No connection',\n    offlineHint: 'Check your connection and try again.',\n    retry: 'Retry',\n    saveError: 'Could not save. Please try again.',\n    leaveError: 'Could not leave. Please try again.',\n    transferTitle: 'Transfer ownership',\n    transferHint: 'Choose a member to transfer ownership of this organization.',\n    transferSelect: 'Select new owner',\n    transferCta: 'Transfer',\n    transferConfirm: 'Transfer ownership to this member? You will lose the owner role.',\n    transferSuccess: 'Ownership transferred.',\n    transferError: 'Could not transfer ownership.',\n    inviteCtaTitle: 'Want to add someone?',\n    inviteCtaHint: 'Invite users to join your organization.',\n    inviteOpen: 'Invite',\n    importOpen: 'Import',\n    apiKeysOpen: 'Manage',\n    apiKeysSectionTitle: 'Integrations (API Keys)',\n    apiKeysSectionHint: 'Connect your external systems to this organization via API Key.',\n    apiKeysMoreInfo: 'More information',\n    apiKeysInfoTitle: 'API integrations',\n    apiKeysInfoSubtitle: 'What can you do with an API Key?',\n    apiKeysInfoContent:\n      'An API Key lets you automate operations in your organization from your own systems, without opening the app. It is ideal for machine-to-machine integrations: sync users from your ERP, bulk-assign roles, or query data for your internal reports.\\n\\nWith a key you can provision and manage members, assign roles and permissions, read organization data, and connect existing workflows.\\n\\nEach key carries only the permissions you assign — grant the minimum needed and revoke it at any time from the Integrations section.\\n\\nImportant: the secret is shown only once when the key is created. Store it somewhere safe (secret manager, environment variable). If you lose it, create a new key and revoke the old one.',\n    apiKeysInfoClose: 'Close',\n    orgsMoreInfo: 'Learn more about organizations',\n    orgsInfoTitle: 'What are organizations?',\n    orgsInfoSubtitle: 'Everything you need to know',\n    orgsInfoClose: 'Close',\n    orgsInfoContent:\n      'Organizations let you separate your projects and data by company, team, or context. You can belong to multiple organizations and switch between them at any time.\\n\\nEach organization has its own members, roles, and permissions. The active organization determines what data you see and what actions you can take.\\n\\nYou can create a new organization or join an existing one via invitation.',\n    viewMemberCta: 'View member',\n    roleViewer: 'Viewer',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles & permissions',\n    rolesHint:\n      'Your organization has roles that control what each member can see and do. Each role carries a set of associated permissions.',\n    rolesViewPerms: 'View roles & permissions',\n    rolesSystemBadge: 'System',\n    permAll: 'All',\n    permUsers: 'Users',\n    permDocuments: 'Documents',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Templates',\n    permRead: 'Read',\n    permWrite: 'Write',\n    permCreate: 'Create',\n    permDelete: 'Delete',\n    permManage: 'Manage',\n    membersShowMore: 'Show more',\n  },\n};\n"]}

package/esm2022/lib/components/organisms/qr-scanner/qr-scanner.component.mjs

@@ -0,0 +1,310 @@
+import { Component, EventEmitter, Input, Output, ViewChild, inject, signal, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonButton, IonIcon, IonSelect, IonSelectOption, IonSpinner } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { cameraOutline, stopCircleOutline, videocamOffOutline, warningOutline } from 'ionicons/icons';
+import { BrowserMultiFormatReader } from '@zxing/browser';
+import { I18nService } from '../../../services/i18n';
+import { QR_SCANNER_I18N } from './qr-scanner.i18n';
+import * as i0 from "@angular/core";
+addIcons({
+    cameraOutline,
+    stopCircleOutline,
+    videocamOffOutline,
+    warningOutline,
+});
+/**
+ * val-qr-scanner
+ *
+ * Organism: scanner de códigos QR por cámara (`@zxing/browser` +
+ * `@zxing/library`). Emite el texto decodificado por `(scanned)`.
+ *
+ * Maneja: permiso de cámara denegado (`denied`), ausencia de cámara
+ * (`no-camera`), selector cuando hay varias cámaras, y botón start/stop. Hace
+ * cleanup del stream en `ngOnDestroy`. i18n auto-registrado (namespace
+ * `QrScanner`).
+ *
+ * Object-first (`@Input() props`) + un único `@Output() scanned`.
+ *
+ * @example
+ * ```html
+ * <val-qr-scanner [props]="{ continuous: true }" (scanned)="onScan($event)" />
+ * ```
+ */
+export class QrScannerComponent {
+    constructor() {
+        this.props = {};
+        /** Emite el texto decodificado del QR. */
+        this.scanned = new EventEmitter();
+        this.i18n = inject(I18nService);
+        this.state = signal('idle');
+        this.devices = signal([]);
+        this.activeDeviceId = signal(undefined);
+        this.reader = null;
+        this.controls = null;
+        // Anti-rebote: ignora la misma lectura repetida dentro de `dedupeMs`.
+        this.lastValue = '';
+        this.lastAt = 0;
+        this.viewReady = false;
+        if (!this.i18n.hasNamespace('QrScanner')) {
+            this.i18n.registerContent('QrScanner', QR_SCANNER_I18N);
+        }
+    }
+    ngAfterViewInit() {
+        this.viewReady = true;
+        if (this.props.autoStart) {
+            void this.start();
+        }
+    }
+    ngOnDestroy() {
+        this.teardown();
+    }
+    t(key) {
+        return this.i18n.t(key, 'QrScanner');
+    }
+    stateMessage() {
+        switch (this.state()) {
+            case 'denied':
+                return this.t('denied');
+            case 'no-camera':
+                return this.t('noCamera');
+            default:
+                return this.t('error');
+        }
+    }
+    deviceLabel(d) {
+        return d.label || `${this.t('cameraLabel')} ${this.devices().indexOf(d) + 1}`;
+    }
+    async start(deviceId) {
+        if (!this.viewReady)
+            return;
+        this.teardown();
+        this.state.set('starting');
+        try {
+            this.reader = new BrowserMultiFormatReader();
+            // Enumerar cámaras. Algunos navegadores solo dan labels tras conceder
+            // permiso, así que esto puede devolver labels vacíos la 1ª vez.
+            let cams = [];
+            try {
+                cams = await BrowserMultiFormatReader.listVideoInputDevices();
+            }
+            catch {
+                cams = [];
+            }
+            this.devices.set(cams);
+            // Preferir la trasera (environment) si el label lo sugiere.
+            const target = deviceId ||
+                this.activeDeviceId() ||
+                cams.find(c => /back|rear|environment|trasera/i.test(c.label))?.deviceId ||
+                cams[0]?.deviceId;
+            this.activeDeviceId.set(target);
+            this.controls = await this.reader.decodeFromVideoDevice(target, this.videoRef.nativeElement, result => {
+                if (result) {
+                    this.handleResult(result.getText());
+                }
+            });
+            this.state.set('scanning');
+        }
+        catch (err) {
+            this.handleStartError(err);
+        }
+    }
+    stop() {
+        this.teardown();
+        this.state.set('idle');
+    }
+    async onSelectDevice(deviceId) {
+        if (deviceId && deviceId !== this.activeDeviceId()) {
+            await this.start(deviceId);
+        }
+    }
+    handleResult(text) {
+        const now = Date.now();
+        const dedupe = this.props.dedupeMs ?? 1500;
+        if (text === this.lastValue && now - this.lastAt < dedupe) {
+            return;
+        }
+        this.lastValue = text;
+        this.lastAt = now;
+        this.scanned.emit(text);
+        // Modo no continuo: detener tras el primer match (la página reanuda si
+        // quiere). `continuous` default true → seguir escaneando.
+        if (this.props.continuous === false) {
+            this.stop();
+        }
+    }
+    handleStartError(err) {
+        const name = err?.name ?? '';
+        if (name === 'NotAllowedError' || name === 'SecurityError') {
+            this.state.set('denied');
+        }
+        else if (name === 'NotFoundError' || name === 'OverconstrainedError') {
+            this.state.set('no-camera');
+        }
+        else {
+            this.state.set('error');
+        }
+        this.teardown(false);
+    }
+    /** Detiene el decode + libera el stream de la cámara. */
+    teardown(resetState = true) {
+        try {
+            this.controls?.stop();
+        }
+        catch {
+            // ignore
+        }
+        this.controls = null;
+        const video = this.videoRef?.nativeElement;
+        const stream = video?.srcObject;
+        if (stream) {
+            stream.getTracks().forEach(track => track.stop());
+            video.srcObject = null;
+        }
+        this.reader = null;
+        if (resetState) {
+            this.lastValue = '';
+            this.lastAt = 0;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrScannerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: QrScannerComponent, isStandalone: true, selector: "val-qr-scanner", inputs: { props: "props" }, outputs: { scanned: "scanned" }, viewQueries: [{ propertyName: "videoRef", first: true, predicate: ["video"], descendants: true }], ngImport: i0, template: `
+    <div class="qr-scanner">
+      <div class="qr-scanner__viewport" [class.is-active]="state() === 'scanning'">
+        <video #video class="qr-scanner__video" muted playsinline></video>
+
+        @if (state() === 'idle') {
+          <div class="qr-scanner__overlay">
+            <ion-icon name="camera-outline" class="qr-scanner__overlay-icon" />
+          </div>
+        }
+
+        @if (state() === 'starting') {
+          <div class="qr-scanner__overlay">
+            <ion-spinner name="crescent" />
+            <p>{{ t('starting') }}</p>
+          </div>
+        }
+
+        @if (state() === 'scanning') {
+          <div class="qr-scanner__frame"></div>
+        }
+      </div>
+
+      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {
+        <div class="qr-scanner__message">
+          <ion-icon [name]="state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'" />
+          <span>{{ stateMessage() }}</span>
+        </div>
+      }
+
+      @if (state() === 'scanning' || state() === 'starting') {
+        <p class="qr-scanner__hint">{{ t('hint') }}</p>
+      }
+
+      @if (devices().length > 1 && state() === 'scanning') {
+        <ion-select
+          class="qr-scanner__select"
+          [label]="t('cameraLabel')"
+          labelPlacement="stacked"
+          interface="popover"
+          [value]="activeDeviceId()"
+          (ionChange)="onSelectDevice($any($event).detail.value)"
+        >
+          @for (d of devices(); track d.deviceId) {
+            <ion-select-option [value]="d.deviceId">{{ deviceLabel(d) }}</ion-select-option>
+          }
+        </ion-select>
+      }
+
+      <div class="qr-scanner__actions">
+        @if (state() === 'scanning' || state() === 'starting') {
+          <ion-button fill="outline" color="dark" (click)="stop()">
+            <ion-icon name="stop-circle-outline" slot="start" />
+            {{ props.stopLabel || t('stop') }}
+          </ion-button>
+        } @else {
+          <ion-button color="dark" (click)="start()">
+            <ion-icon name="camera-outline" slot="start" />
+            {{ props.startLabel || t('start') }}
+          </ion-button>
+        }
+      </div>
+    </div>
+  `, isInline: true, styles: ["@charset \"UTF-8\";:host{display:block}.qr-scanner{display:flex;flex-direction:column;align-items:stretch;gap:12px;max-width:420px;margin:0 auto}.qr-scanner__viewport{position:relative;width:100%;aspect-ratio:1/1;border-radius:16px;overflow:hidden;background:var(--ion-color-dark, #1c1c1e);display:flex;align-items:center;justify-content:center}.qr-scanner__video{width:100%;height:100%;object-fit:cover;display:block}.qr-scanner__overlay{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--ion-color-light, #f4f5f8)}.qr-scanner__overlay p{margin:0;font-size:.875rem}.qr-scanner__overlay-icon{font-size:3rem;opacity:.6}.qr-scanner__frame{position:absolute;inset:18%;border:3px solid var(--ion-color-primary, #ff00b2);border-radius:12px;box-shadow:0 0 0 9999px #00000040;pointer-events:none}.qr-scanner__message{display:flex;align-items:center;gap:8px;padding:12px 14px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);color:var(--ion-color-medium, #6b6675);font-size:.875rem}.qr-scanner__message ion-icon{font-size:1.25rem;flex-shrink:0}.qr-scanner__hint{margin:0;text-align:center;font-size:.8125rem;color:var(--ion-color-medium, #6b6675)}.qr-scanner__select{--padding-start: 0}.qr-scanner__actions{display:flex;justify-content:center}.qr-scanner__actions ion-button{--border-radius: 999px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { 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: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { kind: "component", type: IonSelectOption, selector: "ion-select-option", inputs: ["disabled", "value"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrScannerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-qr-scanner', standalone: true, imports: [CommonModule, IonButton, IonIcon, IonSpinner, IonSelect, IonSelectOption], template: `
+    <div class="qr-scanner">
+      <div class="qr-scanner__viewport" [class.is-active]="state() === 'scanning'">
+        <video #video class="qr-scanner__video" muted playsinline></video>
+
+        @if (state() === 'idle') {
+          <div class="qr-scanner__overlay">
+            <ion-icon name="camera-outline" class="qr-scanner__overlay-icon" />
+          </div>
+        }
+
+        @if (state() === 'starting') {
+          <div class="qr-scanner__overlay">
+            <ion-spinner name="crescent" />
+            <p>{{ t('starting') }}</p>
+          </div>
+        }
+
+        @if (state() === 'scanning') {
+          <div class="qr-scanner__frame"></div>
+        }
+      </div>
+
+      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {
+        <div class="qr-scanner__message">
+          <ion-icon [name]="state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'" />
+          <span>{{ stateMessage() }}</span>
+        </div>
+      }
+
+      @if (state() === 'scanning' || state() === 'starting') {
+        <p class="qr-scanner__hint">{{ t('hint') }}</p>
+      }
+
+      @if (devices().length > 1 && state() === 'scanning') {
+        <ion-select
+          class="qr-scanner__select"
+          [label]="t('cameraLabel')"
+          labelPlacement="stacked"
+          interface="popover"
+          [value]="activeDeviceId()"
+          (ionChange)="onSelectDevice($any($event).detail.value)"
+        >
+          @for (d of devices(); track d.deviceId) {
+            <ion-select-option [value]="d.deviceId">{{ deviceLabel(d) }}</ion-select-option>
+          }
+        </ion-select>
+      }
+
+      <div class="qr-scanner__actions">
+        @if (state() === 'scanning' || state() === 'starting') {
+          <ion-button fill="outline" color="dark" (click)="stop()">
+            <ion-icon name="stop-circle-outline" slot="start" />
+            {{ props.stopLabel || t('stop') }}
+          </ion-button>
+        } @else {
+          <ion-button color="dark" (click)="start()">
+            <ion-icon name="camera-outline" slot="start" />
+            {{ props.startLabel || t('start') }}
+          </ion-button>
+        }
+      </div>
+    </div>
+  `, styles: ["@charset \"UTF-8\";:host{display:block}.qr-scanner{display:flex;flex-direction:column;align-items:stretch;gap:12px;max-width:420px;margin:0 auto}.qr-scanner__viewport{position:relative;width:100%;aspect-ratio:1/1;border-radius:16px;overflow:hidden;background:var(--ion-color-dark, #1c1c1e);display:flex;align-items:center;justify-content:center}.qr-scanner__video{width:100%;height:100%;object-fit:cover;display:block}.qr-scanner__overlay{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--ion-color-light, #f4f5f8)}.qr-scanner__overlay p{margin:0;font-size:.875rem}.qr-scanner__overlay-icon{font-size:3rem;opacity:.6}.qr-scanner__frame{position:absolute;inset:18%;border:3px solid var(--ion-color-primary, #ff00b2);border-radius:12px;box-shadow:0 0 0 9999px #00000040;pointer-events:none}.qr-scanner__message{display:flex;align-items:center;gap:8px;padding:12px 14px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);color:var(--ion-color-medium, #6b6675);font-size:.875rem}.qr-scanner__message ion-icon{font-size:1.25rem;flex-shrink:0}.qr-scanner__hint{margin:0;text-align:center;font-size:.8125rem;color:var(--ion-color-medium, #6b6675)}.qr-scanner__select{--padding-start: 0}.qr-scanner__actions{display:flex;justify-content:center}.qr-scanner__actions ion-button{--border-radius: 999px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { props: [{
+                type: Input
+            }], scanned: [{
+                type: Output
+            }], videoRef: [{
+                type: ViewChild,
+                args: ['video']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qr-scanner.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/qr-scanner/qr-scanner.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,YAAY,EACZ,KAAK,EAEL,MAAM,EACN,SAAS,EACT,MAAM,EACN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvG,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACtG,OAAO,EAAE,wBAAwB,EAAoB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;;AAEpD,QAAQ,CAAC;IACP,aAAa;IACb,iBAAiB;IACjB,kBAAkB;IAClB,cAAc;CACf,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAuEH,MAAM,OAAO,kBAAkB;IAuB7B;QAtBS,UAAK,GAAsB,EAAE,CAAC;QAEvC,0CAA0C;QAChC,YAAO,GAAG,IAAI,YAAY,EAAU,CAAC;QAIvC,SAAI,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAE1B,UAAK,GAAG,MAAM,CAAiB,MAAM,CAAC,CAAC;QACvC,YAAO,GAAG,MAAM,CAAoB,EAAE,CAAC,CAAC;QACxC,mBAAc,GAAG,MAAM,CAAqB,SAAS,CAAC,CAAC;QAExD,WAAM,GAAoC,IAAI,CAAC;QAC/C,aAAQ,GAA4B,IAAI,CAAC;QAEjD,sEAAsE;QAC9D,cAAS,GAAG,EAAE,CAAC;QACf,WAAM,GAAG,CAAC,CAAC;QAEX,cAAS,GAAG,KAAK,CAAC;QAGxB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;YACzB,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,CAAC,CAAC,GAAW;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACvC,CAAC;IAED,YAAY;QACV,QAAQ,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;YACrB,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC1B,KAAK,WAAW;gBACd,OAAO,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;YAC5B;gBACE,OAAO,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,WAAW,CAAC,CAAkB;QAC5B,OAAO,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;IAChF,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,QAAiB;QAC3B,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAC5B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAE3B,IAAI,CAAC;YACH,IAAI,CAAC,MAAM,GAAG,IAAI,wBAAwB,EAAE,CAAC;YAE7C,sEAAsE;YACtE,gEAAgE;YAChE,IAAI,IAAI,GAAsB,EAAE,CAAC;YACjC,IAAI,CAAC;gBACH,IAAI,GAAG,MAAM,wBAAwB,CAAC,qBAAqB,EAAE,CAAC;YAChE,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,GAAG,EAAE,CAAC;YACZ,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAEvB,4DAA4D;YAC5D,MAAM,MAAM,GACV,QAAQ;gBACR,IAAI,CAAC,cAAc,EAAE;gBACrB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,gCAAgC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ;gBACxE,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC;YAEpB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAEhC,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE;gBACpG,IAAI,MAAM,EAAE,CAAC;oBACX,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;gBACtC,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,IAAI;QACF,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,QAAgB;QACnC,IAAI,QAAQ,IAAI,QAAQ,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACnD,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAEO,YAAY,CAAC,IAAY;QAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC;QAC3C,IAAI,IAAI,KAAK,IAAI,CAAC,SAAS,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;YAC1D,OAAO;QACT,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QAElB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAExB,uEAAuE;QACvE,0DAA0D;QAC1D,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;YACpC,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,GAAY;QACnC,MAAM,IAAI,GAAI,GAAgC,EAAE,IAAI,IAAI,EAAE,CAAC;QAC3D,IAAI,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;YAC3D,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,IAAI,KAAK,eAAe,IAAI,IAAI,KAAK,sBAAsB,EAAE,CAAC;YACvE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,yDAAyD;IACjD,QAAQ,CAAC,UAAU,GAAG,IAAI;QAChC,IAAI,CAAC;YACH,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,SAAS;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC;QAC3C,MAAM,MAAM,GAAG,KAAK,EAAE,SAA+B,CAAC;QACtD,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAClD,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACzB,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QAEnB,IAAI,UAAU,EAAE,CAAC;YACf,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;+GAhKU,kBAAkB;mGAAlB,kBAAkB,0OAlEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DT,06CAhES,YAAY,+BAAE,SAAS,oPAAE,OAAO,2JAAE,UAAU,yGAAE,SAAS,kVAAE,eAAe;;4FAmEvE,kBAAkB;kBAtE9B,SAAS;+BACE,gBAAgB,cACd,IAAI,WACP,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,CAAC,YACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DT;wDAIQ,KAAK;sBAAb,KAAK;gBAGI,OAAO;sBAAhB,MAAM;gBAEa,QAAQ;sBAA3B,SAAS;uBAAC,OAAO","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  ViewChild,\n  inject,\n  signal,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { IonButton, IonIcon, IonSelect, IonSelectOption, IonSpinner } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { cameraOutline, stopCircleOutline, videocamOffOutline, warningOutline } from 'ionicons/icons';\nimport { BrowserMultiFormatReader, IScannerControls } from '@zxing/browser';\n\nimport { I18nService } from '../../../services/i18n';\nimport { QrScannerMetadata, QrScannerState } from './types';\nimport { QR_SCANNER_I18N } from './qr-scanner.i18n';\n\naddIcons({\n  cameraOutline,\n  stopCircleOutline,\n  videocamOffOutline,\n  warningOutline,\n});\n\n/**\n * val-qr-scanner\n *\n * Organism: scanner de códigos QR por cámara (`@zxing/browser` +\n * `@zxing/library`). Emite el texto decodificado por `(scanned)`.\n *\n * Maneja: permiso de cámara denegado (`denied`), ausencia de cámara\n * (`no-camera`), selector cuando hay varias cámaras, y botón start/stop. Hace\n * cleanup del stream en `ngOnDestroy`. i18n auto-registrado (namespace\n * `QrScanner`).\n *\n * Object-first (`@Input() props`) + un único `@Output() scanned`.\n *\n * @example\n * ```html\n * <val-qr-scanner [props]=\"{ continuous: true }\" (scanned)=\"onScan($event)\" />\n * ```\n */\n@Component({\n  selector: 'val-qr-scanner',\n  standalone: true,\n  imports: [CommonModule, IonButton, IonIcon, IonSpinner, IonSelect, IonSelectOption],\n  template: `\n    <div class=\"qr-scanner\">\n      <div class=\"qr-scanner__viewport\" [class.is-active]=\"state() === 'scanning'\">\n        <video #video class=\"qr-scanner__video\" muted playsinline></video>\n\n        @if (state() === 'idle') {\n          <div class=\"qr-scanner__overlay\">\n            <ion-icon name=\"camera-outline\" class=\"qr-scanner__overlay-icon\" />\n          </div>\n        }\n\n        @if (state() === 'starting') {\n          <div class=\"qr-scanner__overlay\">\n            <ion-spinner name=\"crescent\" />\n            <p>{{ t('starting') }}</p>\n          </div>\n        }\n\n        @if (state() === 'scanning') {\n          <div class=\"qr-scanner__frame\"></div>\n        }\n      </div>\n\n      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {\n        <div class=\"qr-scanner__message\">\n          <ion-icon [name]=\"state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'\" />\n          <span>{{ stateMessage() }}</span>\n        </div>\n      }\n\n      @if (state() === 'scanning' || state() === 'starting') {\n        <p class=\"qr-scanner__hint\">{{ t('hint') }}</p>\n      }\n\n      @if (devices().length > 1 && state() === 'scanning') {\n        <ion-select\n          class=\"qr-scanner__select\"\n          [label]=\"t('cameraLabel')\"\n          labelPlacement=\"stacked\"\n          interface=\"popover\"\n          [value]=\"activeDeviceId()\"\n          (ionChange)=\"onSelectDevice($any($event).detail.value)\"\n        >\n          @for (d of devices(); track d.deviceId) {\n            <ion-select-option [value]=\"d.deviceId\">{{ deviceLabel(d) }}</ion-select-option>\n          }\n        </ion-select>\n      }\n\n      <div class=\"qr-scanner__actions\">\n        @if (state() === 'scanning' || state() === 'starting') {\n          <ion-button fill=\"outline\" color=\"dark\" (click)=\"stop()\">\n            <ion-icon name=\"stop-circle-outline\" slot=\"start\" />\n            {{ props.stopLabel || t('stop') }}\n          </ion-button>\n        } @else {\n          <ion-button color=\"dark\" (click)=\"start()\">\n            <ion-icon name=\"camera-outline\" slot=\"start\" />\n            {{ props.startLabel || t('start') }}\n          </ion-button>\n        }\n      </div>\n    </div>\n  `,\n  styleUrls: ['./qr-scanner.component.scss'],\n})\nexport class QrScannerComponent implements AfterViewInit, OnDestroy {\n  @Input() props: QrScannerMetadata = {};\n\n  /** Emite el texto decodificado del QR. */\n  @Output() scanned = new EventEmitter<string>();\n\n  @ViewChild('video') videoRef!: ElementRef<HTMLVideoElement>;\n\n  private i18n = inject(I18nService);\n\n  readonly state = signal<QrScannerState>('idle');\n  readonly devices = signal<MediaDeviceInfo[]>([]);\n  readonly activeDeviceId = signal<string | undefined>(undefined);\n\n  private reader: BrowserMultiFormatReader | null = null;\n  private controls: IScannerControls | null = null;\n\n  // Anti-rebote: ignora la misma lectura repetida dentro de `dedupeMs`.\n  private lastValue = '';\n  private lastAt = 0;\n\n  private viewReady = false;\n\n  constructor() {\n    if (!this.i18n.hasNamespace('QrScanner')) {\n      this.i18n.registerContent('QrScanner', QR_SCANNER_I18N);\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.viewReady = true;\n    if (this.props.autoStart) {\n      void this.start();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.teardown();\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, 'QrScanner');\n  }\n\n  stateMessage(): string {\n    switch (this.state()) {\n      case 'denied':\n        return this.t('denied');\n      case 'no-camera':\n        return this.t('noCamera');\n      default:\n        return this.t('error');\n    }\n  }\n\n  deviceLabel(d: MediaDeviceInfo): string {\n    return d.label || `${this.t('cameraLabel')} ${this.devices().indexOf(d) + 1}`;\n  }\n\n  async start(deviceId?: string): Promise<void> {\n    if (!this.viewReady) return;\n    this.teardown();\n    this.state.set('starting');\n\n    try {\n      this.reader = new BrowserMultiFormatReader();\n\n      // Enumerar cámaras. Algunos navegadores solo dan labels tras conceder\n      // permiso, así que esto puede devolver labels vacíos la 1ª vez.\n      let cams: MediaDeviceInfo[] = [];\n      try {\n        cams = await BrowserMultiFormatReader.listVideoInputDevices();\n      } catch {\n        cams = [];\n      }\n      this.devices.set(cams);\n\n      // Preferir la trasera (environment) si el label lo sugiere.\n      const target =\n        deviceId ||\n        this.activeDeviceId() ||\n        cams.find(c => /back|rear|environment|trasera/i.test(c.label))?.deviceId ||\n        cams[0]?.deviceId;\n\n      this.activeDeviceId.set(target);\n\n      this.controls = await this.reader.decodeFromVideoDevice(target, this.videoRef.nativeElement, result => {\n        if (result) {\n          this.handleResult(result.getText());\n        }\n      });\n\n      this.state.set('scanning');\n    } catch (err) {\n      this.handleStartError(err);\n    }\n  }\n\n  stop(): void {\n    this.teardown();\n    this.state.set('idle');\n  }\n\n  async onSelectDevice(deviceId: string): Promise<void> {\n    if (deviceId && deviceId !== this.activeDeviceId()) {\n      await this.start(deviceId);\n    }\n  }\n\n  private handleResult(text: string): void {\n    const now = Date.now();\n    const dedupe = this.props.dedupeMs ?? 1500;\n    if (text === this.lastValue && now - this.lastAt < dedupe) {\n      return;\n    }\n    this.lastValue = text;\n    this.lastAt = now;\n\n    this.scanned.emit(text);\n\n    // Modo no continuo: detener tras el primer match (la página reanuda si\n    // quiere). `continuous` default true → seguir escaneando.\n    if (this.props.continuous === false) {\n      this.stop();\n    }\n  }\n\n  private handleStartError(err: unknown): void {\n    const name = (err as { name?: string } | null)?.name ?? '';\n    if (name === 'NotAllowedError' || name === 'SecurityError') {\n      this.state.set('denied');\n    } else if (name === 'NotFoundError' || name === 'OverconstrainedError') {\n      this.state.set('no-camera');\n    } else {\n      this.state.set('error');\n    }\n    this.teardown(false);\n  }\n\n  /** Detiene el decode + libera el stream de la cámara. */\n  private teardown(resetState = true): void {\n    try {\n      this.controls?.stop();\n    } catch {\n      // ignore\n    }\n    this.controls = null;\n\n    const video = this.videoRef?.nativeElement;\n    const stream = video?.srcObject as MediaStream | null;\n    if (stream) {\n      stream.getTracks().forEach(track => track.stop());\n      video.srcObject = null;\n    }\n    this.reader = null;\n\n    if (resetState) {\n      this.lastValue = '';\n      this.lastAt = 0;\n    }\n  }\n}\n"]}

package/esm2022/lib/components/organisms/qr-scanner/qr-scanner.i18n.mjs

@@ -0,0 +1,28 @@
+/**
+ * Defaults i18n (es/en) del `val-qr-scanner`. Auto-registrados en el
+ * constructor (namespace `QrScanner`) — el consumer NUNCA tiene que
+ * registrarlos. Override por props (start/stop) o registrando el namespace.
+ */
+export const QR_SCANNER_I18N = {
+    es: {
+        start: 'Iniciar cámara',
+        stop: 'Detener',
+        starting: 'Iniciando cámara…',
+        hint: 'Apunta la cámara al código QR de la entrada.',
+        cameraLabel: 'Cámara',
+        denied: 'No se pudo acceder a la cámara. Revisa los permisos del navegador e inténtalo de nuevo.',
+        noCamera: 'No se encontró ninguna cámara en este dispositivo.',
+        error: 'Ocurrió un problema con la cámara. Inténtalo de nuevo.',
+    },
+    en: {
+        start: 'Start camera',
+        stop: 'Stop',
+        starting: 'Starting camera…',
+        hint: 'Point the camera at the ticket QR code.',
+        cameraLabel: 'Camera',
+        denied: 'Could not access the camera. Check your browser permissions and try again.',
+        noCamera: 'No camera was found on this device.',
+        error: 'Something went wrong with the camera. Please try again.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/qr-scanner/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# 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.1024';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC4xMDI0JztcbiJdfQ==
+export const VERSION = '2.0.1026';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC4xMDI2JztcbiJdfQ==