valtech-components 2.0.821 → 2.0.823

package/esm2022/lib/services/qr-generator/qr-generator.service.mjs

@@ -0,0 +1,341 @@
+import { Injectable } from '@angular/core';
+import QRCodeStyling from 'qr-code-styling';
+import { QR_PRESETS, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * QrGeneratorService
+ *
+ * A comprehensive service for generating, customizing, and manipulating QR codes.
+ * Uses qr-code-styling library for high-quality, customizable QR code generation.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const qr = await this.qrService.generate({ data: 'https://example.com' });
+ * console.log(qr.dataUrl); // base64 image
+ * ```
+ *
+ * @example With customization
+ * ```typescript
+ * const qr = await this.qrService.generate({
+ *   data: 'https://example.com',
+ *   width: 400,
+ *   dotsStyle: 'rounded',
+ *   dotsColor: '#3880ff',
+ *   logo: { src: 'logo.png', width: 60 }
+ * });
+ * ```
+ *
+ * @example Using presets
+ * ```typescript
+ * const qr = await this.qrService.generateFromPreset('modern', 'https://example.com');
+ * ```
+ */
+export class QrGeneratorService {
+    /**
+     * Generate a QR code with the given configuration.
+     *
+     * @param config - QR code configuration
+     * @returns Promise<QrResult> - Generated QR code result
+     *
+     * @example
+     * ```typescript
+     * const qr = await this.qrService.generate({
+     *   data: 'https://myapp.com/product/123',
+     *   width: 300,
+     *   dotsStyle: 'rounded',
+     *   dotsColor: '#000000',
+     *   backgroundColor: '#ffffff'
+     * });
+     * ```
+     */
+    async generate(config) {
+        // Merge with defaults
+        const finalConfig = {
+            width: 300,
+            height: config.height || config.width || 300,
+            margin: 0,
+            dotsStyle: 'square',
+            dotsColor: '#000000',
+            backgroundColor: '#ffffff',
+            errorCorrectionLevel: 'M',
+            format: 'png',
+            quality: 1,
+            ...config,
+        };
+        // Build qr-code-styling options
+        const qrOptions = {
+            width: finalConfig.width,
+            height: finalConfig.height,
+            data: finalConfig.data,
+            margin: finalConfig.margin,
+            qrOptions: {
+                errorCorrectionLevel: finalConfig.errorCorrectionLevel,
+            },
+            dotsOptions: {
+                type: finalConfig.dotsStyle,
+                ...this.buildColorOptions(finalConfig.dotsColor),
+            },
+            backgroundOptions: {
+                ...this.buildColorOptions(finalConfig.backgroundColor),
+            },
+            cornersSquareOptions: finalConfig.cornersSquareColor || finalConfig.cornersSquareStyle
+                ? {
+                    type: finalConfig.cornersSquareStyle,
+                    ...this.buildColorOptions(finalConfig.cornersSquareColor || finalConfig.dotsColor),
+                }
+                : undefined,
+            cornersDotOptions: finalConfig.cornersDotColor || finalConfig.cornersDotStyle
+                ? {
+                    type: finalConfig.cornersDotStyle,
+                    ...this.buildColorOptions(finalConfig.cornersDotColor || finalConfig.dotsColor),
+                }
+                : undefined,
+        };
+        // Add logo if provided
+        if (finalConfig.logo) {
+            qrOptions.image = finalConfig.logo.src;
+            qrOptions.imageOptions = {
+                hideBackgroundDots: finalConfig.logo.hideBackgroundDots ?? true,
+                imageSize: 0.4,
+                margin: finalConfig.logo.margin ?? 5,
+                crossOrigin: 'anonymous',
+            };
+        }
+        // Create QR code instance
+        const qrCode = new QRCodeStyling(qrOptions);
+        // Generate blob
+        const format = finalConfig.format || 'png';
+        const mimeType = this.getMimeType(format);
+        const extension = format === 'jpeg' ? 'jpg' : format;
+        let blob;
+        let svg;
+        let dataUrl;
+        if (format === 'svg') {
+            // Get SVG data
+            const svgData = await qrCode.getRawData('svg');
+            if (!svgData) {
+                throw new Error('Failed to generate SVG');
+            }
+            blob = svgData;
+            svg = await blob.text();
+            dataUrl = `data:${mimeType};base64,${btoa(svg)}`;
+        }
+        else {
+            // Get image blob
+            const imageBlob = await qrCode.getRawData(format);
+            if (!imageBlob) {
+                throw new Error('Failed to generate image');
+            }
+            blob = imageBlob;
+            dataUrl = await this.blobToDataUrl(blob);
+        }
+        return {
+            config: finalConfig,
+            dataUrl,
+            blob,
+            svg,
+            mimeType,
+            extension,
+            generatedAt: new Date(),
+        };
+    }
+    /**
+     * Generate a QR code using a preset configuration.
+     *
+     * @param preset - Preset name ('default', 'rounded', 'dots', 'classy', 'modern')
+     * @param data - Data to encode
+     * @param overrides - Optional configuration overrides
+     * @returns Promise<QrResult>
+     */
+    async generateFromPreset(preset, data, overrides) {
+        const presetConfig = QR_PRESETS[preset] || QR_PRESETS['default'];
+        return this.generate({
+            ...presetConfig,
+            ...overrides,
+            data,
+        });
+    }
+    /**
+     * Download the QR code as a file.
+     *
+     * @param qr - QR result to download
+     * @param options - Download options
+     */
+    async download(qr, options) {
+        const filename = options?.filename || `qr-code-${Date.now()}`;
+        const format = options?.format || qr.config.format || 'png';
+        const extension = format === 'jpeg' ? 'jpg' : format;
+        let blob = qr.blob;
+        // Convert if different format requested
+        if (options?.format && options.format !== qr.config.format) {
+            const newQr = await this.generate({
+                ...qr.config,
+                format: options.format,
+            });
+            blob = newQr.blob;
+        }
+        // Create download link
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `${filename}.${extension}`;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Copy the QR code to clipboard as an image.
+     *
+     * @param qr - QR result to copy
+     * @returns Promise<boolean> - Whether copy was successful
+     */
+    async copyToClipboard(qr) {
+        try {
+            // Clipboard API requires PNG format
+            let pngBlob = qr.blob;
+            if (qr.mimeType !== 'image/png') {
+                const pngQr = await this.generate({
+                    ...qr.config,
+                    format: 'png',
+                });
+                pngBlob = pngQr.blob;
+            }
+            await navigator.clipboard.write([
+                new ClipboardItem({
+                    'image/png': pngBlob,
+                }),
+            ]);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to copy QR to clipboard:', error);
+            return false;
+        }
+    }
+    /**
+     * Share the QR code using Web Share API.
+     *
+     * @param qr - QR result to share
+     * @param options - Share options
+     * @returns Promise<boolean> - Whether share was successful
+     */
+    async share(qr, options) {
+        if (!navigator.share || !navigator.canShare) {
+            console.warn('Web Share API not available');
+            return false;
+        }
+        try {
+            const filename = options?.filename || `qr-code-${Date.now()}.${qr.extension}`;
+            const file = new File([qr.blob], filename, { type: qr.mimeType });
+            const shareData = {
+                title: options?.title || 'QR Code',
+                text: options?.text,
+                files: [file],
+            };
+            if (navigator.canShare(shareData)) {
+                await navigator.share(shareData);
+                return true;
+            }
+            // Fallback without file
+            await navigator.share({
+                title: options?.title || 'QR Code',
+                text: options?.text,
+            });
+            return true;
+        }
+        catch (error) {
+            if (error.name !== 'AbortError') {
+                console.error('Failed to share QR:', error);
+            }
+            return false;
+        }
+    }
+    /**
+     * Get the QR code as a base64 string (without data URL prefix).
+     *
+     * @param qr - QR result
+     * @returns Base64 string
+     */
+    toBase64(qr) {
+        const prefix = `data:${qr.mimeType};base64,`;
+        if (qr.dataUrl.startsWith(prefix)) {
+            return qr.dataUrl.substring(prefix.length);
+        }
+        return qr.dataUrl;
+    }
+    /**
+     * Get the QR code as a data URL.
+     *
+     * @param qr - QR result
+     * @returns Data URL string
+     */
+    toDataUrl(qr) {
+        return qr.dataUrl;
+    }
+    /**
+     * Get the QR code as a Blob.
+     *
+     * @param qr - QR result
+     * @returns Blob
+     */
+    toBlob(qr) {
+        return qr.blob;
+    }
+    /**
+     * Check if Web Share API is available.
+     */
+    canShare() {
+        return !!(navigator.share && navigator.canShare);
+    }
+    /**
+     * Check if Clipboard API is available for images.
+     */
+    canCopyToClipboard() {
+        return !!(navigator.clipboard && navigator.clipboard.write);
+    }
+    // === Private Helpers ===
+    buildColorOptions(color) {
+        if (!color) {
+            return {};
+        }
+        if (typeof color === 'string') {
+            return { color };
+        }
+        // Gradient
+        const gradient = color;
+        return {
+            gradient: {
+                type: gradient.type,
+                rotation: gradient.rotation || 0,
+                colorStops: gradient.colorStops,
+            },
+        };
+    }
+    getMimeType(format) {
+        const mimeTypes = {
+            png: 'image/png',
+            jpeg: 'image/jpeg',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+        };
+        return mimeTypes[format] || 'image/png';
+    }
+    blobToDataUrl(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qr-generator.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr-generator/qr-generator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport QRCodeStyling from 'qr-code-styling';\nimport {\n  QrConfig,\n  QrResult,\n  QrDownloadOptions,\n  QrShareOptions,\n  QrColorConfig,\n  QrGradient,\n  QR_PRESETS,\n} from './types';\n\n/**\n * QrGeneratorService\n *\n * A comprehensive service for generating, customizing, and manipulating QR codes.\n * Uses qr-code-styling library for high-quality, customizable QR code generation.\n *\n * @example Basic usage\n * ```typescript\n * const qr = await this.qrService.generate({ data: 'https://example.com' });\n * console.log(qr.dataUrl); // base64 image\n * ```\n *\n * @example With customization\n * ```typescript\n * const qr = await this.qrService.generate({\n *   data: 'https://example.com',\n *   width: 400,\n *   dotsStyle: 'rounded',\n *   dotsColor: '#3880ff',\n *   logo: { src: 'logo.png', width: 60 }\n * });\n * ```\n *\n * @example Using presets\n * ```typescript\n * const qr = await this.qrService.generateFromPreset('modern', 'https://example.com');\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class QrGeneratorService {\n  /**\n   * Generate a QR code with the given configuration.\n   *\n   * @param config - QR code configuration\n   * @returns Promise<QrResult> - Generated QR code result\n   *\n   * @example\n   * ```typescript\n   * const qr = await this.qrService.generate({\n   *   data: 'https://myapp.com/product/123',\n   *   width: 300,\n   *   dotsStyle: 'rounded',\n   *   dotsColor: '#000000',\n   *   backgroundColor: '#ffffff'\n   * });\n   * ```\n   */\n  async generate(config: QrConfig): Promise<QrResult> {\n\n    // Merge with defaults\n    const finalConfig: QrConfig = {\n      width: 300,\n      height: config.height || config.width || 300,\n      margin: 0,\n      dotsStyle: 'square',\n      dotsColor: '#000000',\n      backgroundColor: '#ffffff',\n      errorCorrectionLevel: 'M',\n      format: 'png',\n      quality: 1,\n      ...config,\n    };\n\n    // Build qr-code-styling options\n    const qrOptions: any = {\n      width: finalConfig.width,\n      height: finalConfig.height,\n      data: finalConfig.data,\n      margin: finalConfig.margin,\n      qrOptions: {\n        errorCorrectionLevel: finalConfig.errorCorrectionLevel,\n      },\n      dotsOptions: {\n        type: finalConfig.dotsStyle,\n        ...this.buildColorOptions(finalConfig.dotsColor),\n      },\n      backgroundOptions: {\n        ...this.buildColorOptions(finalConfig.backgroundColor),\n      },\n      cornersSquareOptions: finalConfig.cornersSquareColor || finalConfig.cornersSquareStyle\n        ? {\n            type: finalConfig.cornersSquareStyle,\n            ...this.buildColorOptions(finalConfig.cornersSquareColor || finalConfig.dotsColor),\n          }\n        : undefined,\n      cornersDotOptions: finalConfig.cornersDotColor || finalConfig.cornersDotStyle\n        ? {\n            type: finalConfig.cornersDotStyle,\n            ...this.buildColorOptions(finalConfig.cornersDotColor || finalConfig.dotsColor),\n          }\n        : undefined,\n    };\n\n    // Add logo if provided\n    if (finalConfig.logo) {\n      qrOptions.image = finalConfig.logo.src;\n      qrOptions.imageOptions = {\n        hideBackgroundDots: finalConfig.logo.hideBackgroundDots ?? true,\n        imageSize: 0.4,\n        margin: finalConfig.logo.margin ?? 5,\n        crossOrigin: 'anonymous',\n      };\n    }\n\n    // Create QR code instance\n    const qrCode = new QRCodeStyling(qrOptions);\n\n    // Generate blob\n    const format = finalConfig.format || 'png';\n    const mimeType = this.getMimeType(format);\n    const extension = format === 'jpeg' ? 'jpg' : format;\n\n    let blob: Blob;\n    let svg: string | undefined;\n    let dataUrl: string;\n\n    if (format === 'svg') {\n      // Get SVG data\n      const svgData = await qrCode.getRawData('svg');\n      if (!svgData) {\n        throw new Error('Failed to generate SVG');\n      }\n      blob = svgData as Blob;\n      svg = await blob.text();\n      dataUrl = `data:${mimeType};base64,${btoa(svg)}`;\n    } else {\n      // Get image blob\n      const imageBlob = await qrCode.getRawData(format as 'png' | 'jpeg' | 'webp');\n      if (!imageBlob) {\n        throw new Error('Failed to generate image');\n      }\n      blob = imageBlob as Blob;\n      dataUrl = await this.blobToDataUrl(blob);\n    }\n\n    return {\n      config: finalConfig,\n      dataUrl,\n      blob,\n      svg,\n      mimeType,\n      extension,\n      generatedAt: new Date(),\n    };\n  }\n\n  /**\n   * Generate a QR code using a preset configuration.\n   *\n   * @param preset - Preset name ('default', 'rounded', 'dots', 'classy', 'modern')\n   * @param data - Data to encode\n   * @param overrides - Optional configuration overrides\n   * @returns Promise<QrResult>\n   */\n  async generateFromPreset(\n    preset: keyof typeof QR_PRESETS | string,\n    data: string,\n    overrides?: Partial<QrConfig>\n  ): Promise<QrResult> {\n    const presetConfig = QR_PRESETS[preset] || QR_PRESETS['default'];\n    return this.generate({\n      ...presetConfig,\n      ...overrides,\n      data,\n    });\n  }\n\n  /**\n   * Download the QR code as a file.\n   *\n   * @param qr - QR result to download\n   * @param options - Download options\n   */\n  async download(qr: QrResult, options?: QrDownloadOptions): Promise<void> {\n    const filename = options?.filename || `qr-code-${Date.now()}`;\n    const format = options?.format || qr.config.format || 'png';\n    const extension = format === 'jpeg' ? 'jpg' : format;\n\n    let blob = qr.blob;\n\n    // Convert if different format requested\n    if (options?.format && options.format !== qr.config.format) {\n      const newQr = await this.generate({\n        ...qr.config,\n        format: options.format,\n      });\n      blob = newQr.blob;\n    }\n\n    // Create download link\n    const url = URL.createObjectURL(blob);\n    const link = document.createElement('a');\n    link.href = url;\n    link.download = `${filename}.${extension}`;\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n  }\n\n  /**\n   * Copy the QR code to clipboard as an image.\n   *\n   * @param qr - QR result to copy\n   * @returns Promise<boolean> - Whether copy was successful\n   */\n  async copyToClipboard(qr: QrResult): Promise<boolean> {\n    try {\n      // Clipboard API requires PNG format\n      let pngBlob = qr.blob;\n\n      if (qr.mimeType !== 'image/png') {\n        const pngQr = await this.generate({\n          ...qr.config,\n          format: 'png',\n        });\n        pngBlob = pngQr.blob;\n      }\n\n      await navigator.clipboard.write([\n        new ClipboardItem({\n          'image/png': pngBlob,\n        }),\n      ]);\n\n      return true;\n    } catch (error) {\n      console.error('Failed to copy QR to clipboard:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Share the QR code using Web Share API.\n   *\n   * @param qr - QR result to share\n   * @param options - Share options\n   * @returns Promise<boolean> - Whether share was successful\n   */\n  async share(qr: QrResult, options?: QrShareOptions): Promise<boolean> {\n    if (!navigator.share || !navigator.canShare) {\n      console.warn('Web Share API not available');\n      return false;\n    }\n\n    try {\n      const filename = options?.filename || `qr-code-${Date.now()}.${qr.extension}`;\n      const file = new File([qr.blob], filename, { type: qr.mimeType });\n\n      const shareData: ShareData = {\n        title: options?.title || 'QR Code',\n        text: options?.text,\n        files: [file],\n      };\n\n      if (navigator.canShare(shareData)) {\n        await navigator.share(shareData);\n        return true;\n      }\n\n      // Fallback without file\n      await navigator.share({\n        title: options?.title || 'QR Code',\n        text: options?.text,\n      });\n\n      return true;\n    } catch (error) {\n      if ((error as Error).name !== 'AbortError') {\n        console.error('Failed to share QR:', error);\n      }\n      return false;\n    }\n  }\n\n  /**\n   * Get the QR code as a base64 string (without data URL prefix).\n   *\n   * @param qr - QR result\n   * @returns Base64 string\n   */\n  toBase64(qr: QrResult): string {\n    const prefix = `data:${qr.mimeType};base64,`;\n    if (qr.dataUrl.startsWith(prefix)) {\n      return qr.dataUrl.substring(prefix.length);\n    }\n    return qr.dataUrl;\n  }\n\n  /**\n   * Get the QR code as a data URL.\n   *\n   * @param qr - QR result\n   * @returns Data URL string\n   */\n  toDataUrl(qr: QrResult): string {\n    return qr.dataUrl;\n  }\n\n  /**\n   * Get the QR code as a Blob.\n   *\n   * @param qr - QR result\n   * @returns Blob\n   */\n  toBlob(qr: QrResult): Blob {\n    return qr.blob;\n  }\n\n  /**\n   * Check if Web Share API is available.\n   */\n  canShare(): boolean {\n    return !!(navigator.share && navigator.canShare);\n  }\n\n  /**\n   * Check if Clipboard API is available for images.\n   */\n  canCopyToClipboard(): boolean {\n    return !!(navigator.clipboard && navigator.clipboard.write);\n  }\n\n  // === Private Helpers ===\n\n  private buildColorOptions(color?: QrColorConfig): any {\n    if (!color) {\n      return {};\n    }\n\n    if (typeof color === 'string') {\n      return { color };\n    }\n\n    // Gradient\n    const gradient = color as QrGradient;\n    return {\n      gradient: {\n        type: gradient.type,\n        rotation: gradient.rotation || 0,\n        colorStops: gradient.colorStops,\n      },\n    };\n  }\n\n  private getMimeType(format: string): string {\n    const mimeTypes: Record<string, string> = {\n      png: 'image/png',\n      jpeg: 'image/jpeg',\n      webp: 'image/webp',\n      svg: 'image/svg+xml',\n    };\n    return mimeTypes[format] || 'image/png';\n  }\n\n  private blobToDataUrl(blob: Blob): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const reader = new FileReader();\n      reader.onloadend = () => resolve(reader.result as string);\n      reader.onerror = reject;\n      reader.readAsDataURL(blob);\n    });\n  }\n}\n"]}

package/esm2022/lib/services/qr-generator/types.mjs

@@ -0,0 +1,46 @@
+/**
+ * Default presets for quick styling.
+ */
+export const QR_PRESETS = {
+    default: {
+        width: 300,
+        dotsStyle: 'square',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+        errorCorrectionLevel: 'M',
+    },
+    rounded: {
+        width: 300,
+        dotsStyle: 'rounded',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    dots: {
+        width: 300,
+        dotsStyle: 'dots',
+        cornersSquareStyle: 'dot',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    classy: {
+        width: 300,
+        dotsStyle: 'classy',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#000000',
+        backgroundColor: '#ffffff',
+    },
+    modern: {
+        width: 300,
+        dotsStyle: 'extra-rounded',
+        cornersSquareStyle: 'extra-rounded',
+        cornersDotStyle: 'dot',
+        dotsColor: '#1a1a1a',
+        backgroundColor: '#ffffff',
+        margin: 2,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr-generator/types.ts"],"names":[],"mappings":"AAkKA;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAsC;IAC3D,OAAO,EAAE;QACP,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,QAAQ;QACnB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,oBAAoB,EAAE,GAAG;KAC1B;IACD,OAAO,EAAE;QACP,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,SAAS;QACpB,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,IAAI,EAAE;QACJ,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,MAAM;QACjB,kBAAkB,EAAE,KAAK;QACzB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,MAAM,EAAE;QACN,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,QAAQ;QACnB,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;KAC3B;IACD,MAAM,EAAE;QACN,KAAK,EAAE,GAAG;QACV,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,eAAe;QACnC,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,MAAM,EAAE,CAAC;KACV;CACF,CAAC","sourcesContent":["/**\n * Style options for QR code dots (data modules).\n */\nexport type QrDotsStyle = 'square' | 'dots' | 'rounded' | 'extra-rounded' | 'classy' | 'classy-rounded';\n\n/**\n * Style options for QR code corner squares.\n */\nexport type QrCornersSquareStyle = 'square' | 'dot' | 'extra-rounded';\n\n/**\n * Style options for QR code corner dots.\n */\nexport type QrCornersDotStyle = 'square' | 'dot';\n\n/**\n * Output format for the generated QR code.\n */\nexport type QrOutputFormat = 'svg' | 'png' | 'jpeg' | 'webp';\n\n/**\n * Error correction level for QR codes.\n * Higher levels allow more damage tolerance but reduce data capacity.\n */\nexport type QrErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H';\n\n/**\n * Logo/image configuration for the QR code center.\n */\nexport interface QrLogoConfig {\n  /** Image source URL or base64 */\n  src: string;\n  /** Logo width (default: 25% of QR size) */\n  width?: number;\n  /** Logo height (default: same as width) */\n  height?: number;\n  /** Margin around the logo */\n  margin?: number;\n  /** Border radius for rounded corners */\n  borderRadius?: number;\n  /** Whether to hide dots behind the logo */\n  hideBackgroundDots?: boolean;\n}\n\n/**\n * Gradient configuration for QR elements.\n */\nexport interface QrGradient {\n  /** Gradient type */\n  type: 'linear' | 'radial';\n  /** Rotation angle in degrees (for linear) */\n  rotation?: number;\n  /** Color stops */\n  colorStops: Array<{\n    offset: number;\n    color: string;\n  }>;\n}\n\n/**\n * Color configuration - can be solid color or gradient.\n */\nexport type QrColorConfig = string | QrGradient;\n\n/**\n * Complete configuration for QR code generation.\n */\nexport interface QrConfig {\n  /** The data to encode (URL, text, etc.) */\n  data: string;\n\n  // === Size ===\n  /** QR code width in pixels (default: 300) */\n  width?: number;\n  /** QR code height in pixels (default: same as width) */\n  height?: number;\n  /** Quiet zone margin in modules (default: 0) */\n  margin?: number;\n\n  // === Colors ===\n  /** Color/gradient for data dots */\n  dotsColor?: QrColorConfig;\n  /** Background color (default: white) */\n  backgroundColor?: QrColorConfig;\n  /** Color for corner squares */\n  cornersSquareColor?: QrColorConfig;\n  /** Color for corner dots */\n  cornersDotColor?: QrColorConfig;\n\n  // === Styles ===\n  /** Style of data dots (default: 'square') */\n  dotsStyle?: QrDotsStyle;\n  /** Style of corner squares (default: 'square') */\n  cornersSquareStyle?: QrCornersSquareStyle;\n  /** Style of corner dots (default: 'square') */\n  cornersDotStyle?: QrCornersDotStyle;\n\n  // === Logo ===\n  /** Logo/image configuration */\n  logo?: QrLogoConfig;\n\n  // === Technical ===\n  /** Error correction level (default: 'M') */\n  errorCorrectionLevel?: QrErrorCorrectionLevel;\n\n  // === Output ===\n  /** Output format (default: 'png') */\n  format?: QrOutputFormat;\n  /** Quality for jpeg/webp (0-1, default: 1) */\n  quality?: number;\n}\n\n/**\n * Result from QR code generation.\n */\nexport interface QrResult {\n  /** Original configuration used */\n  config: QrConfig;\n  /** Generated data as base64 data URL */\n  dataUrl: string;\n  /** Generated data as Blob */\n  blob: Blob;\n  /** SVG string (only when format is 'svg') */\n  svg?: string;\n  /** MIME type of the generated image */\n  mimeType: string;\n  /** File extension */\n  extension: string;\n  /** Timestamp of generation */\n  generatedAt: Date;\n}\n\n/**\n * Options for downloading the QR code.\n */\nexport interface QrDownloadOptions {\n  /** Custom filename (without extension) */\n  filename?: string;\n  /** Override format for download */\n  format?: QrOutputFormat;\n}\n\n/**\n * Options for sharing the QR code.\n */\nexport interface QrShareOptions {\n  /** Share title */\n  title?: string;\n  /** Share text/description */\n  text?: string;\n  /** Custom filename for the shared file */\n  filename?: string;\n}\n\n/**\n * Preset configurations for common use cases.\n */\nexport interface QrPreset {\n  name: string;\n  config: Partial<QrConfig>;\n}\n\n/**\n * Default presets for quick styling.\n */\nexport const QR_PRESETS: Record<string, Partial<QrConfig>> = {\n  default: {\n    width: 300,\n    dotsStyle: 'square',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n    errorCorrectionLevel: 'M',\n  },\n  rounded: {\n    width: 300,\n    dotsStyle: 'rounded',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  dots: {\n    width: 300,\n    dotsStyle: 'dots',\n    cornersSquareStyle: 'dot',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  classy: {\n    width: 300,\n    dotsStyle: 'classy',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#000000',\n    backgroundColor: '#ffffff',\n  },\n  modern: {\n    width: 300,\n    dotsStyle: 'extra-rounded',\n    cornersSquareStyle: 'extra-rounded',\n    cornersDotStyle: 'dot',\n    dotsColor: '#1a1a1a',\n    backgroundColor: '#ffffff',\n    margin: 2,\n  },\n};\n"]}

package/esm2022/lib/services/refreshable-stream/index.mjs

@@ -0,0 +1,8 @@
+/**
+ * Refreshable Stream
+ *
+ * Helper `createRefreshableStream` para vistas con datos Firestore.
+ * Soporta modo one-shot y real-time, con gate de `firebaseAuthReady`.
+ */
+export { createRefreshableStream, } from './refreshable-stream';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3JlZnJlc2hhYmxlLXN0cmVhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE9BQU8sRUFDTCx1QkFBdUIsR0FHeEIsTUFBTSxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVmcmVzaGFibGUgU3RyZWFtXG4gKlxuICogSGVscGVyIGBjcmVhdGVSZWZyZXNoYWJsZVN0cmVhbWAgcGFyYSB2aXN0YXMgY29uIGRhdG9zIEZpcmVzdG9yZS5cbiAqIFNvcG9ydGEgbW9kbyBvbmUtc2hvdCB5IHJlYWwtdGltZSwgY29uIGdhdGUgZGUgYGZpcmViYXNlQXV0aFJlYWR5YC5cbiAqL1xuZXhwb3J0IHtcbiAgY3JlYXRlUmVmcmVzaGFibGVTdHJlYW0sXG4gIHR5cGUgUmVmcmVzaGFibGVTdHJlYW0sXG4gIHR5cGUgUmVmcmVzaGFibGVTdHJlYW1PcHRpb25zLFxufSBmcm9tICcuL3JlZnJlc2hhYmxlLXN0cmVhbSc7XG4iXX0=

package/esm2022/lib/services/refreshable-stream/refreshable-stream.mjs

@@ -0,0 +1,112 @@
+/**
+ * Refreshable Stream
+ *
+ * Helper estándar para vistas que consumen datos de Firestore. Soporta DOS
+ * modos — el caller decide cuál vía la `factory`:
+ *
+ *  - **one-shot** (recomendado por defecto): `() => from(svc.getAllOnce())`.
+ *    Carga una vez y completa. Más barato — sin listener vivo.
+ *  - **real-time**: `() => svc.getAll()`. Listener Firestore que auto-actualiza.
+ *    Solo donde importa (inbox de notificaciones, badges).
+ *
+ * En ambos modos la primera suscripción se gatea por `firebaseAuthReady`
+ * (sesión de Firebase Auth lista) — así el listener/lectura nunca se adjunta
+ * antes de que `request.auth` esté disponible en las reglas de Firestore, lo
+ * que cierra la ventana de `permission-denied` en cold start de PWA.
+ *
+ * El `retry` con backoff corto es solo red de seguridad para reconexiones
+ * transitorias (no para cubrir cold start — eso lo cubre el gate de auth).
+ */
+import { inject, Injector } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { signal } from '@angular/core';
+import { of, race, timer } from 'rxjs';
+import { catchError, retry, switchMap, take, tap, timeout } from 'rxjs/operators';
+import { FirebaseService } from '../firebase/firebase.service';
+/**
+ * Crea un stream refrescable a partir de una factory de Observable.
+ *
+ * DEBE llamarse en un injection context (field initializer o constructor) —
+ * usa `toSignal`/`toObservable`/`inject` internamente.
+ *
+ * @param factory - Función que produce el Observable a consumir. El caller
+ *   decide el modo: `() => from(svc.getAllOnce())` (one-shot) o
+ *   `() => svc.getAll()` (real-time).
+ * @param options - Configuración opcional (fallback, retry, gate).
+ *
+ * @example
+ * ```typescript
+ * // one-shot (recomendado por defecto)
+ * private readonly stream = createRefreshableStream(
+ *   () => from(this.svc.getAllOnce()),
+ * );
+ *
+ * // real-time (inbox)
+ * private readonly stream = createRefreshableStream(
+ *   () => this.notifs.getAll(50),
+ * );
+ *
+ * readonly items = this.stream.data;
+ * readonly loading = this.stream.loading;
+ *
+ * ionViewWillEnter() {
+ *   this.pageRefresh.register(() => this.stream.reload());
+ * }
+ * ```
+ */
+export function createRefreshableStream(factory, options) {
+    const injector = options?.injector ?? inject(Injector);
+    const fallback = (options?.fallback ?? null);
+    const retryCount = options?.retryCount ?? 4;
+    const retryBaseDelayMs = options?.retryBaseDelayMs ?? 500;
+    const gateOnFirebaseAuth = options?.gateOnFirebaseAuth ?? true;
+    const authGateTimeoutMs = options?.authGateTimeoutMs ?? 20000;
+    const firstEmitTimeoutMs = options?.firstEmitTimeoutMs ?? 20000;
+    // FirebaseService es opcional — sin él (apps sin Firebase) no se gatea.
+    const firebase = gateOnFirebaseAuth ? injector.get(FirebaseService, null) : null;
+    const _reload = signal(0);
+    const _loading = signal(true);
+    const _error = signal(false);
+    // Gate de Firebase Auth: el stream no abre la primera suscripción hasta que
+    // la sesión esté confirmada. `race` con un `timer` de seguridad — si la
+    // sesión NUNCA se establece (token inválido, signInWithFirebase falló), el
+    // gate igual se libera tras `authGateTimeoutMs` y la factory procede: si no
+    // hay permiso terminará en estado `error`, jamás en skeleton infinito.
+    const authGate$ = firebase
+        ? race(firebase.firebaseAuthReady$, timer(authGateTimeoutMs)).pipe(take(1))
+        : of(true);
+    const data = toSignal(toObservable(_reload, { injector }).pipe(tap(() => {
+        _loading.set(true);
+        _error.set(false);
+    }), 
+    // Esperar a Firebase Auth listo antes de cada (re)suscripción. Como
+    // `firebaseAuthReady$` completa tras la primera emisión, las reloads
+    // posteriores resuelven el gate de inmediato (auth ya está listo).
+    switchMap(() => authGate$.pipe(switchMap(() => factory().pipe(tap(() => {
+        _loading.set(false);
+        _error.set(false);
+    }), 
+    // Backoff corto exponencial acotado — solo red de seguridad para
+    // reconexiones transitorias, NO para cubrir cold start.
+    retry({
+        count: retryCount,
+        delay: (_err, attempt) => timer(Math.min(retryBaseDelayMs * 2 ** (attempt - 1), 4000)),
+    }), 
+    // Techo absoluto para la PRIMERA emisión. Si la factory no emite
+    // ni valor ni error (servicio nunca inicializado → `EMPTY` →
+    // silencio), `timeout` dispara un error → `catchError` → estado
+    // `error`. Nunca skeleton perpetuo. Va DESPUÉS de `retry` para
+    // que cuente el tiempo total, no por intento.
+    timeout({ first: firstEmitTimeoutMs }), catchError(() => {
+        _loading.set(false);
+        _error.set(true);
+        return of(fallback);
+    })))))), { initialValue: null, injector });
+    return {
+        data,
+        loading: _loading.asReadonly(),
+        error: _error.asReadonly(),
+        reload: () => _reload.update(n => n + 1),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"refreshable-stream.js","sourceRoot":"","sources":["../../../../../../src/lib/services/refreshable-stream/refreshable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Refreshable Stream\n *\n * Helper estándar para vistas que consumen datos de Firestore. Soporta DOS\n * modos — el caller decide cuál vía la `factory`:\n *\n *  - **one-shot** (recomendado por defecto): `() => from(svc.getAllOnce())`.\n *    Carga una vez y completa. Más barato — sin listener vivo.\n *  - **real-time**: `() => svc.getAll()`. Listener Firestore que auto-actualiza.\n *    Solo donde importa (inbox de notificaciones, badges).\n *\n * En ambos modos la primera suscripción se gatea por `firebaseAuthReady`\n * (sesión de Firebase Auth lista) — así el listener/lectura nunca se adjunta\n * antes de que `request.auth` esté disponible en las reglas de Firestore, lo\n * que cierra la ventana de `permission-denied` en cold start de PWA.\n *\n * El `retry` con backoff corto es solo red de seguridad para reconexiones\n * transitorias (no para cubrir cold start — eso lo cubre el gate de auth).\n */\n\nimport { inject, Injector, Signal } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { signal } from '@angular/core';\nimport { Observable, of, race, timer } from 'rxjs';\nimport { catchError, retry, switchMap, take, tap, timeout } from 'rxjs/operators';\n\nimport { FirebaseService } from '../firebase/firebase.service';\n\n/** Opciones de configuración para `createRefreshableStream`. */\nexport interface RefreshableStreamOptions<T> {\n  /**\n   * Valor emitido cuando la factory falla tras agotar los reintentos.\n   * Default: `null`.\n   */\n  fallback?: T;\n  /**\n   * Número máximo de reintentos ante un error de la factory.\n   * Backoff corto — NO cubre cold start (eso lo hace el gate de auth), solo\n   * reconexiones transitorias. Default: 4.\n   */\n  retryCount?: number;\n  /**\n   * Delay base del backoff (ms). El delay efectivo crece exponencialmente\n   * acotado: 500ms → 1s → 2s ... Default: 500.\n   */\n  retryBaseDelayMs?: number;\n  /**\n   * Si `false`, NO espera a `firebaseAuthReady` antes de la primera\n   * suscripción. Útil para streams que no leen Firestore. Default: `true`.\n   */\n  gateOnFirebaseAuth?: boolean;\n  /**\n   * Timeout (ms) del gate de Firebase Auth. Si la sesión de Firebase Auth no\n   * se establece en este tiempo, el stream procede igual (la factory correrá\n   * y, si no hay permiso, terminará en estado `error` — NUNCA en skeleton\n   * infinito). Muy por encima de cualquier handshake real. Default: 20000.\n   */\n  authGateTimeoutMs?: number;\n  /**\n   * Timeout (ms) de la PRIMERA emisión de la factory. Si la factory no emite\n   * ni un valor ni un error en este tiempo (caso típico: un servicio Firestore\n   * que nunca se inicializó → `EMPTY` → silencio total), el stream pasa a\n   * estado `error` en vez de quedarse en skeleton perpetuo. Default: 20000.\n   */\n  firstEmitTimeoutMs?: number;\n  /**\n   * Injector explícito. Solo necesario si `createRefreshableStream` se llama\n   * fuera de un injection context (raro). Por defecto usa `inject(Injector)`.\n   */\n  injector?: Injector;\n}\n\n/**\n * Resultado de `createRefreshableStream`.\n */\nexport interface RefreshableStream<T> {\n  /** Datos actuales. `null` mientras la primera emisión no ha llegado. */\n  readonly data: Signal<T | null>;\n  /** `true` mientras se espera la primera emisión de la suscripción actual. */\n  readonly loading: Signal<boolean>;\n  /** `true` si la factory falló tras agotar los reintentos. */\n  readonly error: Signal<boolean>;\n  /**\n   * Re-suscribe la factory desde cero (nuevo listener / nueva lectura).\n   * Es lo que registra el `PageRefreshService` como handler de pull-to-refresh,\n   * y también el \"reconectar manual\" si un listener murió.\n   */\n  reload: () => void;\n}\n\n/**\n * Crea un stream refrescable a partir de una factory de Observable.\n *\n * DEBE llamarse en un injection context (field initializer o constructor) —\n * usa `toSignal`/`toObservable`/`inject` internamente.\n *\n * @param factory - Función que produce el Observable a consumir. El caller\n *   decide el modo: `() => from(svc.getAllOnce())` (one-shot) o\n *   `() => svc.getAll()` (real-time).\n * @param options - Configuración opcional (fallback, retry, gate).\n *\n * @example\n * ```typescript\n * // one-shot (recomendado por defecto)\n * private readonly stream = createRefreshableStream(\n *   () => from(this.svc.getAllOnce()),\n * );\n *\n * // real-time (inbox)\n * private readonly stream = createRefreshableStream(\n *   () => this.notifs.getAll(50),\n * );\n *\n * readonly items = this.stream.data;\n * readonly loading = this.stream.loading;\n *\n * ionViewWillEnter() {\n *   this.pageRefresh.register(() => this.stream.reload());\n * }\n * ```\n */\nexport function createRefreshableStream<T>(\n  factory: () => Observable<T>,\n  options?: RefreshableStreamOptions<T>\n): RefreshableStream<T> {\n  const injector = options?.injector ?? inject(Injector);\n  const fallback = (options?.fallback ?? null) as T | null;\n  const retryCount = options?.retryCount ?? 4;\n  const retryBaseDelayMs = options?.retryBaseDelayMs ?? 500;\n  const gateOnFirebaseAuth = options?.gateOnFirebaseAuth ?? true;\n  const authGateTimeoutMs = options?.authGateTimeoutMs ?? 20000;\n  const firstEmitTimeoutMs = options?.firstEmitTimeoutMs ?? 20000;\n\n  // FirebaseService es opcional — sin él (apps sin Firebase) no se gatea.\n  const firebase = gateOnFirebaseAuth ? injector.get(FirebaseService, null) : null;\n\n  const _reload = signal(0);\n  const _loading = signal(true);\n  const _error = signal(false);\n\n  // Gate de Firebase Auth: el stream no abre la primera suscripción hasta que\n  // la sesión esté confirmada. `race` con un `timer` de seguridad — si la\n  // sesión NUNCA se establece (token inválido, signInWithFirebase falló), el\n  // gate igual se libera tras `authGateTimeoutMs` y la factory procede: si no\n  // hay permiso terminará en estado `error`, jamás en skeleton infinito.\n  const authGate$: Observable<unknown> = firebase\n    ? race(firebase.firebaseAuthReady$, timer(authGateTimeoutMs)).pipe(take(1))\n    : of(true);\n\n  const data = toSignal(\n    toObservable(_reload, { injector }).pipe(\n      tap(() => {\n        _loading.set(true);\n        _error.set(false);\n      }),\n      // Esperar a Firebase Auth listo antes de cada (re)suscripción. Como\n      // `firebaseAuthReady$` completa tras la primera emisión, las reloads\n      // posteriores resuelven el gate de inmediato (auth ya está listo).\n      switchMap(() =>\n        authGate$.pipe(\n          switchMap(() =>\n            factory().pipe(\n              tap(() => {\n                _loading.set(false);\n                _error.set(false);\n              }),\n              // Backoff corto exponencial acotado — solo red de seguridad para\n              // reconexiones transitorias, NO para cubrir cold start.\n              retry({\n                count: retryCount,\n                delay: (_err, attempt) =>\n                  timer(Math.min(retryBaseDelayMs * 2 ** (attempt - 1), 4000)),\n              }),\n              // Techo absoluto para la PRIMERA emisión. Si la factory no emite\n              // ni valor ni error (servicio nunca inicializado → `EMPTY` →\n              // silencio), `timeout` dispara un error → `catchError` → estado\n              // `error`. Nunca skeleton perpetuo. Va DESPUÉS de `retry` para\n              // que cuente el tiempo total, no por intento.\n              timeout({ first: firstEmitTimeoutMs }),\n              catchError(() => {\n                _loading.set(false);\n                _error.set(true);\n                return of(fallback as T);\n              })\n            )\n          )\n        )\n      )\n    ),\n    { initialValue: null as T | null, injector }\n  );\n\n  return {\n    data,\n    loading: _loading.asReadonly(),\n    error: _error.asReadonly(),\n    reload: () => _reload.update(n => n + 1),\n  };\n}\n"]}