valtech-components 2.0.691 → 2.0.692

package/esm2022/lib/services/firebase/utils/path-builder.mjs

@@ -0,0 +1,195 @@
+/**
+ * Path Builder
+ *
+ * Utilidades para construir rutas de Firestore con templates.
+ * Soporta rutas multi-nivel y anidadas.
+ */
+/**
+ * Construye una ruta de Firestore reemplazando placeholders.
+ *
+ * @param template - Template con placeholders en formato {param}
+ * @param params - Objeto con los valores a reemplazar
+ * @returns Ruta construida
+ * @throws Error si faltan parámetros requeridos
+ *
+ * @example
+ * ```typescript
+ * // Ruta simple
+ * buildPath('users/{userId}', { userId: 'abc123' });
+ * // => 'users/abc123'
+ *
+ * // Ruta anidada
+ * buildPath('users/{userId}/documents/{docId}', {
+ *   userId: 'abc123',
+ *   docId: 'doc456'
+ * });
+ * // => 'users/abc123/documents/doc456'
+ *
+ * // Múltiples niveles
+ * buildPath('orgs/{orgId}/teams/{teamId}/members/{memberId}', {
+ *   orgId: 'org1',
+ *   teamId: 'team2',
+ *   memberId: 'member3'
+ * });
+ * // => 'orgs/org1/teams/team2/members/member3'
+ * ```
+ */
+export function buildPath(template, params) {
+    let result = template;
+    // Encontrar todos los placeholders
+    const placeholders = template.match(/\{([^}]+)\}/g);
+    if (!placeholders) {
+        return template;
+    }
+    for (const placeholder of placeholders) {
+        const key = placeholder.slice(1, -1); // Remover { y }
+        const value = params[key];
+        if (value === undefined || value === null) {
+            throw new Error(`Parámetro requerido '${key}' no proporcionado para la ruta: ${template}`);
+        }
+        if (typeof value !== 'string' || value.trim() === '') {
+            throw new Error(`El parámetro '${key}' debe ser un string no vacío`);
+        }
+        // Validar que no contenga caracteres inválidos para Firestore
+        if (value.includes('/')) {
+            throw new Error(`El parámetro '${key}' no puede contener '/'`);
+        }
+        result = result.replace(placeholder, value);
+    }
+    return result;
+}
+/**
+ * Extrae los nombres de los parámetros de un template de ruta.
+ *
+ * @param template - Template de ruta
+ * @returns Array con los nombres de los parámetros
+ *
+ * @example
+ * ```typescript
+ * extractParams('users/{userId}/documents/{docId}');
+ * // => ['userId', 'docId']
+ * ```
+ */
+export function extractPathParams(template) {
+    const matches = template.match(/\{([^}]+)\}/g);
+    if (!matches)
+        return [];
+    return matches.map((m) => m.slice(1, -1));
+}
+/**
+ * Valida que una ruta de Firestore sea válida.
+ *
+ * @param path - Ruta a validar
+ * @returns true si la ruta es válida
+ *
+ * @example
+ * ```typescript
+ * isValidPath('users/abc123');           // true
+ * isValidPath('users/abc123/documents'); // true
+ * isValidPath('users//documents');       // false (segmento vacío)
+ * isValidPath('');                       // false (vacío)
+ * ```
+ */
+export function isValidPath(path) {
+    if (!path || path.trim() === '')
+        return false;
+    const segments = path.split('/');
+    // No puede tener segmentos vacíos
+    if (segments.some((s) => s.trim() === ''))
+        return false;
+    // No puede empezar o terminar con /
+    if (path.startsWith('/') || path.endsWith('/'))
+        return false;
+    return true;
+}
+/**
+ * Obtiene la ruta de la colección padre de un documento.
+ *
+ * @param documentPath - Ruta completa del documento
+ * @returns Ruta de la colección padre
+ *
+ * @example
+ * ```typescript
+ * getCollectionPath('users/abc123');
+ * // => 'users'
+ *
+ * getCollectionPath('users/abc123/documents/doc456');
+ * // => 'users/abc123/documents'
+ * ```
+ */
+export function getCollectionPath(documentPath) {
+    const segments = documentPath.split('/');
+    if (segments.length < 2) {
+        throw new Error(`Ruta de documento inválida: ${documentPath}`);
+    }
+    return segments.slice(0, -1).join('/');
+}
+/**
+ * Obtiene el ID del documento de una ruta.
+ *
+ * @param documentPath - Ruta completa del documento
+ * @returns ID del documento
+ *
+ * @example
+ * ```typescript
+ * getDocumentId('users/abc123');
+ * // => 'abc123'
+ *
+ * getDocumentId('users/abc123/documents/doc456');
+ * // => 'doc456'
+ * ```
+ */
+export function getDocumentId(documentPath) {
+    const segments = documentPath.split('/');
+    if (segments.length < 2 || segments.length % 2 !== 0) {
+        throw new Error(`Ruta de documento inválida: ${documentPath}`);
+    }
+    return segments[segments.length - 1];
+}
+/**
+ * Verifica si una ruta apunta a un documento (número par de segmentos).
+ *
+ * @param path - Ruta a verificar
+ * @returns true si es una ruta de documento
+ *
+ * @example
+ * ```typescript
+ * isDocumentPath('users/abc123');           // true
+ * isDocumentPath('users');                  // false (colección)
+ * isDocumentPath('users/abc123/documents'); // false (colección)
+ * ```
+ */
+export function isDocumentPath(path) {
+    const segments = path.split('/').filter((s) => s.trim() !== '');
+    return segments.length > 0 && segments.length % 2 === 0;
+}
+/**
+ * Verifica si una ruta apunta a una colección (número impar de segmentos).
+ *
+ * @param path - Ruta a verificar
+ * @returns true si es una ruta de colección
+ */
+export function isCollectionPath(path) {
+    const segments = path.split('/').filter((s) => s.trim() !== '');
+    return segments.length > 0 && segments.length % 2 !== 0;
+}
+/**
+ * Combina una ruta base con segmentos adicionales.
+ *
+ * @param basePath - Ruta base
+ * @param segments - Segmentos adicionales
+ * @returns Ruta combinada
+ *
+ * @example
+ * ```typescript
+ * joinPath('users', 'abc123', 'documents');
+ * // => 'users/abc123/documents'
+ * ```
+ */
+export function joinPath(...segments) {
+    return segments
+        .filter((s) => s && s.trim() !== '')
+        .map((s) => s.replace(/^\/+|\/+$/g, '')) // Remover / al inicio y final
+        .join('/');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"path-builder.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/firebase/utils/path-builder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,SAAS,CAAC,QAAgB,EAAE,MAA8B;IACxE,IAAI,MAAM,GAAG,QAAQ,CAAC;IAEtB,mCAAmC;IACnC,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAEpD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAE1B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,oCAAoC,QAAQ,EAAE,CAAC,CAAC;QAC7F,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,MAAM,IAAI,KAAK,CAAC,iBAAiB,GAAG,+BAA+B,CAAC,CAAC;QACvE,CAAC;QAED,8DAA8D;QAC9D,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB;IAChD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAC/C,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACxB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,KAAK,CAAC;IAE9C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAEjC,kCAAkC;IAClC,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;QAAE,OAAO,KAAK,CAAC;IAExD,oCAAoC;IACpC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAE7D,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,iBAAiB,CAAC,YAAoB;IACpD,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,+BAA+B,YAAY,EAAE,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAAC,YAAoB;IAChD,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,+BAA+B,YAAY,EAAE,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAChE,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAChE,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAG,QAAkB;IAC5C,OAAO,QAAQ;SACZ,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;SACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC,CAAC,8BAA8B;SACtE,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC","sourcesContent":["/**\n * Path Builder\n *\n * Utilidades para construir rutas de Firestore con templates.\n * Soporta rutas multi-nivel y anidadas.\n */\n\n/**\n * Construye una ruta de Firestore reemplazando placeholders.\n *\n * @param template - Template con placeholders en formato {param}\n * @param params - Objeto con los valores a reemplazar\n * @returns Ruta construida\n * @throws Error si faltan parámetros requeridos\n *\n * @example\n * ```typescript\n * // Ruta simple\n * buildPath('users/{userId}', { userId: 'abc123' });\n * // => 'users/abc123'\n *\n * // Ruta anidada\n * buildPath('users/{userId}/documents/{docId}', {\n *   userId: 'abc123',\n *   docId: 'doc456'\n * });\n * // => 'users/abc123/documents/doc456'\n *\n * // Múltiples niveles\n * buildPath('orgs/{orgId}/teams/{teamId}/members/{memberId}', {\n *   orgId: 'org1',\n *   teamId: 'team2',\n *   memberId: 'member3'\n * });\n * // => 'orgs/org1/teams/team2/members/member3'\n * ```\n */\nexport function buildPath(template: string, params: Record<string, string>): string {\n  let result = template;\n\n  // Encontrar todos los placeholders\n  const placeholders = template.match(/\\{([^}]+)\\}/g);\n\n  if (!placeholders) {\n    return template;\n  }\n\n  for (const placeholder of placeholders) {\n    const key = placeholder.slice(1, -1); // Remover { y }\n    const value = params[key];\n\n    if (value === undefined || value === null) {\n      throw new Error(`Parámetro requerido '${key}' no proporcionado para la ruta: ${template}`);\n    }\n\n    if (typeof value !== 'string' || value.trim() === '') {\n      throw new Error(`El parámetro '${key}' debe ser un string no vacío`);\n    }\n\n    // Validar que no contenga caracteres inválidos para Firestore\n    if (value.includes('/')) {\n      throw new Error(`El parámetro '${key}' no puede contener '/'`);\n    }\n\n    result = result.replace(placeholder, value);\n  }\n\n  return result;\n}\n\n/**\n * Extrae los nombres de los parámetros de un template de ruta.\n *\n * @param template - Template de ruta\n * @returns Array con los nombres de los parámetros\n *\n * @example\n * ```typescript\n * extractParams('users/{userId}/documents/{docId}');\n * // => ['userId', 'docId']\n * ```\n */\nexport function extractPathParams(template: string): string[] {\n  const matches = template.match(/\\{([^}]+)\\}/g);\n  if (!matches) return [];\n  return matches.map((m) => m.slice(1, -1));\n}\n\n/**\n * Valida que una ruta de Firestore sea válida.\n *\n * @param path - Ruta a validar\n * @returns true si la ruta es válida\n *\n * @example\n * ```typescript\n * isValidPath('users/abc123');           // true\n * isValidPath('users/abc123/documents'); // true\n * isValidPath('users//documents');       // false (segmento vacío)\n * isValidPath('');                       // false (vacío)\n * ```\n */\nexport function isValidPath(path: string): boolean {\n  if (!path || path.trim() === '') return false;\n\n  const segments = path.split('/');\n\n  // No puede tener segmentos vacíos\n  if (segments.some((s) => s.trim() === '')) return false;\n\n  // No puede empezar o terminar con /\n  if (path.startsWith('/') || path.endsWith('/')) return false;\n\n  return true;\n}\n\n/**\n * Obtiene la ruta de la colección padre de un documento.\n *\n * @param documentPath - Ruta completa del documento\n * @returns Ruta de la colección padre\n *\n * @example\n * ```typescript\n * getCollectionPath('users/abc123');\n * // => 'users'\n *\n * getCollectionPath('users/abc123/documents/doc456');\n * // => 'users/abc123/documents'\n * ```\n */\nexport function getCollectionPath(documentPath: string): string {\n  const segments = documentPath.split('/');\n  if (segments.length < 2) {\n    throw new Error(`Ruta de documento inválida: ${documentPath}`);\n  }\n  return segments.slice(0, -1).join('/');\n}\n\n/**\n * Obtiene el ID del documento de una ruta.\n *\n * @param documentPath - Ruta completa del documento\n * @returns ID del documento\n *\n * @example\n * ```typescript\n * getDocumentId('users/abc123');\n * // => 'abc123'\n *\n * getDocumentId('users/abc123/documents/doc456');\n * // => 'doc456'\n * ```\n */\nexport function getDocumentId(documentPath: string): string {\n  const segments = documentPath.split('/');\n  if (segments.length < 2 || segments.length % 2 !== 0) {\n    throw new Error(`Ruta de documento inválida: ${documentPath}`);\n  }\n  return segments[segments.length - 1];\n}\n\n/**\n * Verifica si una ruta apunta a un documento (número par de segmentos).\n *\n * @param path - Ruta a verificar\n * @returns true si es una ruta de documento\n *\n * @example\n * ```typescript\n * isDocumentPath('users/abc123');           // true\n * isDocumentPath('users');                  // false (colección)\n * isDocumentPath('users/abc123/documents'); // false (colección)\n * ```\n */\nexport function isDocumentPath(path: string): boolean {\n  const segments = path.split('/').filter((s) => s.trim() !== '');\n  return segments.length > 0 && segments.length % 2 === 0;\n}\n\n/**\n * Verifica si una ruta apunta a una colección (número impar de segmentos).\n *\n * @param path - Ruta a verificar\n * @returns true si es una ruta de colección\n */\nexport function isCollectionPath(path: string): boolean {\n  const segments = path.split('/').filter((s) => s.trim() !== '');\n  return segments.length > 0 && segments.length % 2 !== 0;\n}\n\n/**\n * Combina una ruta base con segmentos adicionales.\n *\n * @param basePath - Ruta base\n * @param segments - Segmentos adicionales\n * @returns Ruta combinada\n *\n * @example\n * ```typescript\n * joinPath('users', 'abc123', 'documents');\n * // => 'users/abc123/documents'\n * ```\n */\nexport function joinPath(...segments: string[]): string {\n  return segments\n    .filter((s) => s && s.trim() !== '')\n    .map((s) => s.replace(/^\\/+|\\/+$/g, '')) // Remover / al inicio y final\n    .join('/');\n}\n"]}

package/esm2022/lib/services/firebase/utils/query-builder.mjs

@@ -0,0 +1,302 @@
+/**
+ * Query Builder
+ *
+ * Builder fluido para construir queries de Firestore de manera legible.
+ * Alternativa más expresiva a pasar objetos QueryOptions directamente.
+ */
+/**
+ * Builder fluido para queries de Firestore.
+ *
+ * @example
+ * ```typescript
+ * // Construir query con builder
+ * const options = new QueryBuilder()
+ *   .where('status', '==', 'active')
+ *   .where('age', '>=', 18)
+ *   .orderBy('createdAt', 'desc')
+ *   .limit(10)
+ *   .build();
+ *
+ * // Usar con FirestoreService
+ * const users = await firestoreService.getDocs<User>('users', options);
+ *
+ * // O con método estático
+ * const options2 = QueryBuilder.create()
+ *   .where('category', '==', 'electronics')
+ *   .orderBy('price', 'asc')
+ *   .build();
+ * ```
+ */
+export class QueryBuilder {
+    constructor() {
+        this.whereConditions = [];
+        this.orderByConditions = [];
+    }
+    /**
+     * Crea una nueva instancia del builder (método estático alternativo).
+     */
+    static create() {
+        return new QueryBuilder();
+    }
+    /**
+     * Agrega una condición where.
+     *
+     * @param field - Campo a filtrar
+     * @param operator - Operador de comparación
+     * @param value - Valor a comparar
+     *
+     * @example
+     * ```typescript
+     * builder.where('status', '==', 'active')
+     * builder.where('price', '>=', 100)
+     * builder.where('tags', 'array-contains', 'featured')
+     * builder.where('category', 'in', ['electronics', 'books'])
+     * ```
+     */
+    where(field, operator, value) {
+        this.whereConditions.push({ field, operator, value });
+        return this;
+    }
+    /**
+     * Shortcut para where con operador '=='.
+     *
+     * @example
+     * ```typescript
+     * builder.whereEquals('status', 'active')
+     * // equivalente a: builder.where('status', '==', 'active')
+     * ```
+     */
+    whereEquals(field, value) {
+        return this.where(field, '==', value);
+    }
+    /**
+     * Shortcut para where con operador '!='.
+     */
+    whereNotEquals(field, value) {
+        return this.where(field, '!=', value);
+    }
+    /**
+     * Shortcut para where con operador '>'.
+     */
+    whereGreaterThan(field, value) {
+        return this.where(field, '>', value);
+    }
+    /**
+     * Shortcut para where con operador '>='.
+     */
+    whereGreaterOrEqual(field, value) {
+        return this.where(field, '>=', value);
+    }
+    /**
+     * Shortcut para where con operador '<'.
+     */
+    whereLessThan(field, value) {
+        return this.where(field, '<', value);
+    }
+    /**
+     * Shortcut para where con operador '<='.
+     */
+    whereLessOrEqual(field, value) {
+        return this.where(field, '<=', value);
+    }
+    /**
+     * Shortcut para where con operador 'array-contains'.
+     *
+     * @example
+     * ```typescript
+     * builder.whereArrayContains('tags', 'featured')
+     * ```
+     */
+    whereArrayContains(field, value) {
+        return this.where(field, 'array-contains', value);
+    }
+    /**
+     * Shortcut para where con operador 'array-contains-any'.
+     *
+     * @example
+     * ```typescript
+     * builder.whereArrayContainsAny('tags', ['featured', 'new'])
+     * ```
+     */
+    whereArrayContainsAny(field, values) {
+        return this.where(field, 'array-contains-any', values);
+    }
+    /**
+     * Shortcut para where con operador 'in'.
+     *
+     * @example
+     * ```typescript
+     * builder.whereIn('status', ['active', 'pending'])
+     * ```
+     */
+    whereIn(field, values) {
+        return this.where(field, 'in', values);
+    }
+    /**
+     * Shortcut para where con operador 'not-in'.
+     */
+    whereNotIn(field, values) {
+        return this.where(field, 'not-in', values);
+    }
+    /**
+     * Agrega ordenamiento por un campo.
+     *
+     * @param field - Campo por el cual ordenar
+     * @param direction - Dirección: 'asc' o 'desc' (default: 'asc')
+     *
+     * @example
+     * ```typescript
+     * builder.orderBy('createdAt', 'desc')
+     * builder.orderBy('name') // asc por defecto
+     * ```
+     */
+    orderBy(field, direction = 'asc') {
+        this.orderByConditions.push({ field, direction });
+        return this;
+    }
+    /**
+     * Shortcut para orderBy descendente.
+     */
+    orderByDesc(field) {
+        return this.orderBy(field, 'desc');
+    }
+    /**
+     * Shortcut para orderBy ascendente.
+     */
+    orderByAsc(field) {
+        return this.orderBy(field, 'asc');
+    }
+    /**
+     * Limita el número de resultados.
+     *
+     * @param count - Número máximo de documentos
+     *
+     * @example
+     * ```typescript
+     * builder.limit(10)
+     * ```
+     */
+    limit(count) {
+        if (count <= 0) {
+            throw new Error('El límite debe ser mayor a 0');
+        }
+        this.limitValue = count;
+        return this;
+    }
+    /**
+     * Cursor para paginación: empezar después de un documento.
+     *
+     * @param cursor - Documento o snapshot desde donde continuar
+     *
+     * @example
+     * ```typescript
+     * // Primera página
+     * const page1 = await service.getPaginated('users', builder.limit(10).build());
+     *
+     * // Siguiente página
+     * const page2 = await service.getPaginated('users',
+     *   builder.startAfter(page1.lastDoc).limit(10).build()
+     * );
+     * ```
+     */
+    startAfter(cursor) {
+        this.startAfterValue = cursor;
+        return this;
+    }
+    /**
+     * Cursor para paginación: empezar en un documento.
+     */
+    startAt(cursor) {
+        this.startAtValue = cursor;
+        return this;
+    }
+    /**
+     * Cursor para paginación: terminar antes de un documento.
+     */
+    endBefore(cursor) {
+        this.endBeforeValue = cursor;
+        return this;
+    }
+    /**
+     * Cursor para paginación: terminar en un documento.
+     */
+    endAt(cursor) {
+        this.endAtValue = cursor;
+        return this;
+    }
+    /**
+     * Construye el objeto QueryOptions.
+     *
+     * @returns QueryOptions para usar con FirestoreService
+     */
+    build() {
+        const options = {};
+        if (this.whereConditions.length > 0) {
+            options.where = [...this.whereConditions];
+        }
+        if (this.orderByConditions.length > 0) {
+            options.orderBy = [...this.orderByConditions];
+        }
+        if (this.limitValue !== undefined) {
+            options.limit = this.limitValue;
+        }
+        if (this.startAfterValue !== undefined) {
+            options.startAfter = this.startAfterValue;
+        }
+        if (this.startAtValue !== undefined) {
+            options.startAt = this.startAtValue;
+        }
+        if (this.endBeforeValue !== undefined) {
+            options.endBefore = this.endBeforeValue;
+        }
+        if (this.endAtValue !== undefined) {
+            options.endAt = this.endAtValue;
+        }
+        return options;
+    }
+    /**
+     * Resetea el builder para reutilización.
+     */
+    reset() {
+        this.whereConditions = [];
+        this.orderByConditions = [];
+        this.limitValue = undefined;
+        this.startAfterValue = undefined;
+        this.startAtValue = undefined;
+        this.endBeforeValue = undefined;
+        this.endAtValue = undefined;
+        return this;
+    }
+    /**
+     * Clona el builder actual.
+     */
+    clone() {
+        const cloned = new QueryBuilder();
+        cloned.whereConditions = [...this.whereConditions];
+        cloned.orderByConditions = [...this.orderByConditions];
+        cloned.limitValue = this.limitValue;
+        cloned.startAfterValue = this.startAfterValue;
+        cloned.startAtValue = this.startAtValue;
+        cloned.endBeforeValue = this.endBeforeValue;
+        cloned.endAtValue = this.endAtValue;
+        return cloned;
+    }
+}
+/**
+ * Función helper para crear un QueryBuilder.
+ *
+ * @example
+ * ```typescript
+ * import { query } from 'valtech-components';
+ *
+ * const options = query()
+ *   .where('status', '==', 'active')
+ *   .orderBy('createdAt', 'desc')
+ *   .limit(10)
+ *   .build();
+ * ```
+ */
+export function query() {
+    return new QueryBuilder();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-builder.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/firebase/utils/query-builder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Query Builder\n *\n * Builder fluido para construir queries de Firestore de manera legible.\n * Alternativa más expresiva a pasar objetos QueryOptions directamente.\n */\n\nimport { OrderByClause, OrderDirection, QueryOptions, WhereClause, WhereOperator } from '../types';\n\n/**\n * Builder fluido para queries de Firestore.\n *\n * @example\n * ```typescript\n * // Construir query con builder\n * const options = new QueryBuilder()\n *   .where('status', '==', 'active')\n *   .where('age', '>=', 18)\n *   .orderBy('createdAt', 'desc')\n *   .limit(10)\n *   .build();\n *\n * // Usar con FirestoreService\n * const users = await firestoreService.getDocs<User>('users', options);\n *\n * // O con método estático\n * const options2 = QueryBuilder.create()\n *   .where('category', '==', 'electronics')\n *   .orderBy('price', 'asc')\n *   .build();\n * ```\n */\nexport class QueryBuilder {\n  private whereConditions: WhereClause[] = [];\n  private orderByConditions: OrderByClause[] = [];\n  private limitValue?: number;\n  private startAfterValue?: unknown;\n  private startAtValue?: unknown;\n  private endBeforeValue?: unknown;\n  private endAtValue?: unknown;\n\n  /**\n   * Crea una nueva instancia del builder (método estático alternativo).\n   */\n  static create(): QueryBuilder {\n    return new QueryBuilder();\n  }\n\n  /**\n   * Agrega una condición where.\n   *\n   * @param field - Campo a filtrar\n   * @param operator - Operador de comparación\n   * @param value - Valor a comparar\n   *\n   * @example\n   * ```typescript\n   * builder.where('status', '==', 'active')\n   * builder.where('price', '>=', 100)\n   * builder.where('tags', 'array-contains', 'featured')\n   * builder.where('category', 'in', ['electronics', 'books'])\n   * ```\n   */\n  where(field: string, operator: WhereOperator, value: unknown): QueryBuilder {\n    this.whereConditions.push({ field, operator, value });\n    return this;\n  }\n\n  /**\n   * Shortcut para where con operador '=='.\n   *\n   * @example\n   * ```typescript\n   * builder.whereEquals('status', 'active')\n   * // equivalente a: builder.where('status', '==', 'active')\n   * ```\n   */\n  whereEquals(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '==', value);\n  }\n\n  /**\n   * Shortcut para where con operador '!='.\n   */\n  whereNotEquals(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '!=', value);\n  }\n\n  /**\n   * Shortcut para where con operador '>'.\n   */\n  whereGreaterThan(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '>', value);\n  }\n\n  /**\n   * Shortcut para where con operador '>='.\n   */\n  whereGreaterOrEqual(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '>=', value);\n  }\n\n  /**\n   * Shortcut para where con operador '<'.\n   */\n  whereLessThan(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '<', value);\n  }\n\n  /**\n   * Shortcut para where con operador '<='.\n   */\n  whereLessOrEqual(field: string, value: unknown): QueryBuilder {\n    return this.where(field, '<=', value);\n  }\n\n  /**\n   * Shortcut para where con operador 'array-contains'.\n   *\n   * @example\n   * ```typescript\n   * builder.whereArrayContains('tags', 'featured')\n   * ```\n   */\n  whereArrayContains(field: string, value: unknown): QueryBuilder {\n    return this.where(field, 'array-contains', value);\n  }\n\n  /**\n   * Shortcut para where con operador 'array-contains-any'.\n   *\n   * @example\n   * ```typescript\n   * builder.whereArrayContainsAny('tags', ['featured', 'new'])\n   * ```\n   */\n  whereArrayContainsAny(field: string, values: unknown[]): QueryBuilder {\n    return this.where(field, 'array-contains-any', values);\n  }\n\n  /**\n   * Shortcut para where con operador 'in'.\n   *\n   * @example\n   * ```typescript\n   * builder.whereIn('status', ['active', 'pending'])\n   * ```\n   */\n  whereIn(field: string, values: unknown[]): QueryBuilder {\n    return this.where(field, 'in', values);\n  }\n\n  /**\n   * Shortcut para where con operador 'not-in'.\n   */\n  whereNotIn(field: string, values: unknown[]): QueryBuilder {\n    return this.where(field, 'not-in', values);\n  }\n\n  /**\n   * Agrega ordenamiento por un campo.\n   *\n   * @param field - Campo por el cual ordenar\n   * @param direction - Dirección: 'asc' o 'desc' (default: 'asc')\n   *\n   * @example\n   * ```typescript\n   * builder.orderBy('createdAt', 'desc')\n   * builder.orderBy('name') // asc por defecto\n   * ```\n   */\n  orderBy(field: string, direction: OrderDirection = 'asc'): QueryBuilder {\n    this.orderByConditions.push({ field, direction });\n    return this;\n  }\n\n  /**\n   * Shortcut para orderBy descendente.\n   */\n  orderByDesc(field: string): QueryBuilder {\n    return this.orderBy(field, 'desc');\n  }\n\n  /**\n   * Shortcut para orderBy ascendente.\n   */\n  orderByAsc(field: string): QueryBuilder {\n    return this.orderBy(field, 'asc');\n  }\n\n  /**\n   * Limita el número de resultados.\n   *\n   * @param count - Número máximo de documentos\n   *\n   * @example\n   * ```typescript\n   * builder.limit(10)\n   * ```\n   */\n  limit(count: number): QueryBuilder {\n    if (count <= 0) {\n      throw new Error('El límite debe ser mayor a 0');\n    }\n    this.limitValue = count;\n    return this;\n  }\n\n  /**\n   * Cursor para paginación: empezar después de un documento.\n   *\n   * @param cursor - Documento o snapshot desde donde continuar\n   *\n   * @example\n   * ```typescript\n   * // Primera página\n   * const page1 = await service.getPaginated('users', builder.limit(10).build());\n   *\n   * // Siguiente página\n   * const page2 = await service.getPaginated('users',\n   *   builder.startAfter(page1.lastDoc).limit(10).build()\n   * );\n   * ```\n   */\n  startAfter(cursor: unknown): QueryBuilder {\n    this.startAfterValue = cursor;\n    return this;\n  }\n\n  /**\n   * Cursor para paginación: empezar en un documento.\n   */\n  startAt(cursor: unknown): QueryBuilder {\n    this.startAtValue = cursor;\n    return this;\n  }\n\n  /**\n   * Cursor para paginación: terminar antes de un documento.\n   */\n  endBefore(cursor: unknown): QueryBuilder {\n    this.endBeforeValue = cursor;\n    return this;\n  }\n\n  /**\n   * Cursor para paginación: terminar en un documento.\n   */\n  endAt(cursor: unknown): QueryBuilder {\n    this.endAtValue = cursor;\n    return this;\n  }\n\n  /**\n   * Construye el objeto QueryOptions.\n   *\n   * @returns QueryOptions para usar con FirestoreService\n   */\n  build(): QueryOptions {\n    const options: QueryOptions = {};\n\n    if (this.whereConditions.length > 0) {\n      options.where = [...this.whereConditions];\n    }\n\n    if (this.orderByConditions.length > 0) {\n      options.orderBy = [...this.orderByConditions];\n    }\n\n    if (this.limitValue !== undefined) {\n      options.limit = this.limitValue;\n    }\n\n    if (this.startAfterValue !== undefined) {\n      options.startAfter = this.startAfterValue;\n    }\n\n    if (this.startAtValue !== undefined) {\n      options.startAt = this.startAtValue;\n    }\n\n    if (this.endBeforeValue !== undefined) {\n      options.endBefore = this.endBeforeValue;\n    }\n\n    if (this.endAtValue !== undefined) {\n      options.endAt = this.endAtValue;\n    }\n\n    return options;\n  }\n\n  /**\n   * Resetea el builder para reutilización.\n   */\n  reset(): QueryBuilder {\n    this.whereConditions = [];\n    this.orderByConditions = [];\n    this.limitValue = undefined;\n    this.startAfterValue = undefined;\n    this.startAtValue = undefined;\n    this.endBeforeValue = undefined;\n    this.endAtValue = undefined;\n    return this;\n  }\n\n  /**\n   * Clona el builder actual.\n   */\n  clone(): QueryBuilder {\n    const cloned = new QueryBuilder();\n    cloned.whereConditions = [...this.whereConditions];\n    cloned.orderByConditions = [...this.orderByConditions];\n    cloned.limitValue = this.limitValue;\n    cloned.startAfterValue = this.startAfterValue;\n    cloned.startAtValue = this.startAtValue;\n    cloned.endBeforeValue = this.endBeforeValue;\n    cloned.endAtValue = this.endAtValue;\n    return cloned;\n  }\n}\n\n/**\n * Función helper para crear un QueryBuilder.\n *\n * @example\n * ```typescript\n * import { query } from 'valtech-components';\n *\n * const options = query()\n *   .where('status', '==', 'active')\n *   .orderBy('createdAt', 'desc')\n *   .limit(10)\n *   .build();\n * ```\n */\nexport function query(): QueryBuilder {\n  return new QueryBuilder();\n}\n"]}

package/esm2022/lib/services/i18n/config.mjs

@@ -0,0 +1,110 @@
+import { makeEnvironmentProviders, APP_INITIALIZER, } from '@angular/core';
+import { DEFAULT_I18N_CONFIG } from './types';
+import { I18nService } from './i18n.service';
+import { VALTECH_DEFAULT_CONTENT } from './default-content';
+/**
+ * Configura el sistema de internacionalización de Valtech Components.
+ *
+ * @param config Configuración de i18n
+ * @returns Providers para agregar en app.config.ts
+ *
+ * @example
+ * // app.config.ts
+ * import { provideValtechI18n } from 'valtech-components';
+ * import { GLOBAL_CONTENT } from './i18n/_global';
+ * import { LOGIN_CONTENT } from './i18n/login.i18n';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideValtechI18n({
+ *       defaultLanguage: 'es',
+ *       supportedLanguages: ['es', 'en'],
+ *       detectBrowserLanguage: true,
+ *       content: {
+ *         '_global': GLOBAL_CONTENT,
+ *         'Login': LOGIN_CONTENT,
+ *       }
+ *     }),
+ *   ]
+ * };
+ */
+export function provideValtechI18n(config = {}) {
+    const mergedConfig = { ...DEFAULT_I18N_CONFIG, ...config };
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (i18n) => {
+                return () => {
+                    // Configurar idiomas soportados
+                    i18n.setI18nLanguages(mergedConfig.supportedLanguages);
+                    // Determinar contenido a registrar
+                    let contentToRegister = {};
+                    if (mergedConfig.includeDefaultContent !== false) {
+                        // Merge: defaults + user config (user gana)
+                        contentToRegister = deepMergeContent(VALTECH_DEFAULT_CONTENT, mergedConfig.content || {});
+                    }
+                    else if (mergedConfig.content) {
+                        // Solo contenido del usuario
+                        contentToRegister = mergedConfig.content;
+                    }
+                    // Registrar contenido
+                    if (Object.keys(contentToRegister).length > 0) {
+                        i18n.registerContentBulk(contentToRegister);
+                    }
+                };
+            },
+            deps: [I18nService],
+            multi: true,
+        },
+    ]);
+}
+/**
+ * Deep merge de ContentStore.
+ * El contenido de `override` sobrescribe keys específicas de `base`.
+ *
+ * @param base - Contenido base (defaults de valtech-components)
+ * @param override - Contenido del usuario que sobrescribe
+ * @returns ContentStore mergeado
+ *
+ * @example
+ * const base = { _global: { es: { ok: 'Aceptar' } } };
+ * const override = { _global: { es: { ok: 'Dale' } } };
+ * // Resultado: { _global: { es: { ok: 'Dale' } } }
+ */
+function deepMergeContent(base, override) {
+    const result = {};
+    // Copiar todos los namespaces del base
+    for (const namespace of Object.keys(base)) {
+        result[namespace] = deepMergeLanguagesContent(base[namespace], {});
+    }
+    // Mergear namespaces del override
+    for (const namespace of Object.keys(override)) {
+        if (result[namespace]) {
+            // Namespace existe en base, hacer deep merge
+            result[namespace] = deepMergeLanguagesContent(result[namespace], override[namespace]);
+        }
+        else {
+            // Namespace nuevo, copiar completo
+            result[namespace] = deepMergeLanguagesContent({}, override[namespace]);
+        }
+    }
+    return result;
+}
+/**
+ * Deep merge de LanguagesContent (un namespace).
+ */
+function deepMergeLanguagesContent(base, override) {
+    const result = {};
+    const allLangs = new Set([
+        ...Object.keys(base),
+        ...Object.keys(override),
+    ]);
+    for (const lang of allLangs) {
+        result[lang] = {
+            ...(base[lang] || {}),
+            ...(override[lang] || {}),
+        };
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../../src/lib/services/i18n/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,wBAAwB,EACxB,eAAe,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAc,mBAAmB,EAA4C,MAAM,SAAS,CAAC;AACpG,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAqB,EAAE;IACxD,MAAM,YAAY,GAAG,EAAE,GAAG,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAAC;IAE3D,OAAO,wBAAwB,CAAC;QAC9B;YACE,OAAO,EAAE,eAAe;YACxB,UAAU,EAAE,CAAC,IAAiB,EAAE,EAAE;gBAChC,OAAO,GAAG,EAAE;oBACV,gCAAgC;oBAChC,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;oBAEvD,mCAAmC;oBACnC,IAAI,iBAAiB,GAAiB,EAAE,CAAC;oBAEzC,IAAI,YAAY,CAAC,qBAAqB,KAAK,KAAK,EAAE,CAAC;wBACjD,4CAA4C;wBAC5C,iBAAiB,GAAG,gBAAgB,CAClC,uBAAuB,EACvB,YAAY,CAAC,OAAO,IAAI,EAAE,CAC3B,CAAC;oBACJ,CAAC;yBAAM,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;wBAChC,6BAA6B;wBAC7B,iBAAiB,GAAG,YAAY,CAAC,OAAO,CAAC;oBAC3C,CAAC;oBAED,sBAAsB;oBACtB,IAAI,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC9C,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;oBAC9C,CAAC;gBACH,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,EAAE,CAAC,WAAW,CAAC;YACnB,KAAK,EAAE,IAAI;SACZ;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,gBAAgB,CAAC,IAAkB,EAAE,QAAsB;IAClE,MAAM,MAAM,GAAiB,EAAE,CAAC;IAEhC,uCAAuC;IACvC,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,MAAM,CAAC,SAAS,CAAC,GAAG,yBAAyB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,kCAAkC;IAClC,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9C,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YACtB,6CAA6C;YAC7C,MAAM,CAAC,SAAS,CAAC,GAAG,yBAAyB,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;QACxF,CAAC;aAAM,CAAC;YACN,mCAAmC;YACnC,MAAM,CAAC,SAAS,CAAC,GAAG,yBAAyB,CAAC,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAS,yBAAyB,CAChC,IAAsB,EACtB,QAA0B;IAE1B,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC;QACvB,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;QACpB,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;KACzB,CAAkB,CAAC;IAEpB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC,GAAG;YACb,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACrB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAC1B,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {\n  EnvironmentProviders,\n  makeEnvironmentProviders,\n  APP_INITIALIZER,\n} from '@angular/core';\nimport { I18nConfig, DEFAULT_I18N_CONFIG, ContentStore, LanguagesContent, I18nLang } from './types';\nimport { I18nService } from './i18n.service';\nimport { VALTECH_DEFAULT_CONTENT } from './default-content';\n\n/**\n * Configura el sistema de internacionalización de Valtech Components.\n *\n * @param config Configuración de i18n\n * @returns Providers para agregar en app.config.ts\n *\n * @example\n * // app.config.ts\n * import { provideValtechI18n } from 'valtech-components';\n * import { GLOBAL_CONTENT } from './i18n/_global';\n * import { LOGIN_CONTENT } from './i18n/login.i18n';\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideValtechI18n({\n *       defaultLanguage: 'es',\n *       supportedLanguages: ['es', 'en'],\n *       detectBrowserLanguage: true,\n *       content: {\n *         '_global': GLOBAL_CONTENT,\n *         'Login': LOGIN_CONTENT,\n *       }\n *     }),\n *   ]\n * };\n */\nexport function provideValtechI18n(config: I18nConfig = {}): EnvironmentProviders {\n  const mergedConfig = { ...DEFAULT_I18N_CONFIG, ...config };\n\n  return makeEnvironmentProviders([\n    {\n      provide: APP_INITIALIZER,\n      useFactory: (i18n: I18nService) => {\n        return () => {\n          // Configurar idiomas soportados\n          i18n.setI18nLanguages(mergedConfig.supportedLanguages);\n\n          // Determinar contenido a registrar\n          let contentToRegister: ContentStore = {};\n\n          if (mergedConfig.includeDefaultContent !== false) {\n            // Merge: defaults + user config (user gana)\n            contentToRegister = deepMergeContent(\n              VALTECH_DEFAULT_CONTENT,\n              mergedConfig.content || {}\n            );\n          } else if (mergedConfig.content) {\n            // Solo contenido del usuario\n            contentToRegister = mergedConfig.content;\n          }\n\n          // Registrar contenido\n          if (Object.keys(contentToRegister).length > 0) {\n            i18n.registerContentBulk(contentToRegister);\n          }\n        };\n      },\n      deps: [I18nService],\n      multi: true,\n    },\n  ]);\n}\n\n/**\n * Deep merge de ContentStore.\n * El contenido de `override` sobrescribe keys específicas de `base`.\n *\n * @param base - Contenido base (defaults de valtech-components)\n * @param override - Contenido del usuario que sobrescribe\n * @returns ContentStore mergeado\n *\n * @example\n * const base = { _global: { es: { ok: 'Aceptar' } } };\n * const override = { _global: { es: { ok: 'Dale' } } };\n * // Resultado: { _global: { es: { ok: 'Dale' } } }\n */\nfunction deepMergeContent(base: ContentStore, override: ContentStore): ContentStore {\n  const result: ContentStore = {};\n\n  // Copiar todos los namespaces del base\n  for (const namespace of Object.keys(base)) {\n    result[namespace] = deepMergeLanguagesContent(base[namespace], {});\n  }\n\n  // Mergear namespaces del override\n  for (const namespace of Object.keys(override)) {\n    if (result[namespace]) {\n      // Namespace existe en base, hacer deep merge\n      result[namespace] = deepMergeLanguagesContent(result[namespace], override[namespace]);\n    } else {\n      // Namespace nuevo, copiar completo\n      result[namespace] = deepMergeLanguagesContent({}, override[namespace]);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Deep merge de LanguagesContent (un namespace).\n */\nfunction deepMergeLanguagesContent(\n  base: LanguagesContent,\n  override: LanguagesContent\n): LanguagesContent {\n  const result: LanguagesContent = {};\n  const allLangs = new Set([\n    ...Object.keys(base),\n    ...Object.keys(override),\n  ]) as Set<I18nLang>;\n\n  for (const lang of allLangs) {\n    result[lang] = {\n      ...(base[lang] || {}),\n      ...(override[lang] || {}),\n    };\n  }\n\n  return result;\n}\n"]}