valtech-components 2.0.795 → 2.0.796

package/esm2022/lib/services/image/image.service.mjs

@@ -0,0 +1,244 @@
+import { Injectable } from '@angular/core';
+import { IMAGE_DEFAULTS, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * ImageService
+ *
+ * Service for image processing including compression, thumbnails, cropping and validation.
+ * Uses HTML Canvas for all operations - no external dependencies.
+ *
+ * @example
+ * ```typescript
+ * const imageService = inject(ImageService);
+ *
+ * // Compress an image
+ * const compressed = await imageService.compress(file, { maxWidth: 800, quality: 0.8 });
+ *
+ * // Generate thumbnail
+ * const thumb = await imageService.thumbnail(file, 150);
+ *
+ * // Validate before processing
+ * const validation = imageService.validate(file, { maxSize: 5 * 1024 * 1024 });
+ * if (!validation.valid) {
+ *   console.error(validation.message);
+ * }
+ * ```
+ */
+export class ImageService {
+    /**
+     * Compress an image maintaining aspect ratio
+     * @param file - File or Blob to compress
+     * @param options - Compression options
+     * @returns Promise with processed image data
+     */
+    async compress(file, options) {
+        const opts = {
+            maxWidth: options?.maxWidth ?? IMAGE_DEFAULTS.maxWidth,
+            maxHeight: options?.maxHeight ?? IMAGE_DEFAULTS.maxHeight,
+            quality: options?.quality ?? IMAGE_DEFAULTS.quality,
+            mimeType: options?.mimeType ?? IMAGE_DEFAULTS.mimeType,
+        };
+        const img = await this.loadImage(file);
+        const { width, height } = this.calculateDimensions(img.width, img.height, opts.maxWidth, opts.maxHeight);
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0, width, height);
+        const blob = await this.canvasToBlob(canvas, opts.mimeType, opts.quality);
+        const dataUrl = canvas.toDataURL(opts.mimeType, opts.quality);
+        return {
+            blob,
+            dataUrl,
+            width,
+            height,
+            size: blob.size,
+        };
+    }
+    /**
+     * Generate a square thumbnail from an image
+     * @param file - File or Blob to process
+     * @param size - Thumbnail size in pixels (default: 150)
+     * @returns Promise with processed thumbnail
+     */
+    async thumbnail(file, size) {
+        const thumbSize = size ?? IMAGE_DEFAULTS.thumbnailSize;
+        const img = await this.loadImage(file);
+        // Calculate square crop from center
+        const minDim = Math.min(img.width, img.height);
+        const cropX = (img.width - minDim) / 2;
+        const cropY = (img.height - minDim) / 2;
+        const canvas = document.createElement('canvas');
+        canvas.width = thumbSize;
+        canvas.height = thumbSize;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, cropX, cropY, minDim, minDim, 0, 0, thumbSize, thumbSize);
+        const blob = await this.canvasToBlob(canvas, IMAGE_DEFAULTS.mimeType, 0.7 // Lower quality for thumbnails
+        );
+        const dataUrl = canvas.toDataURL(IMAGE_DEFAULTS.mimeType, 0.7);
+        return {
+            blob,
+            dataUrl,
+            width: thumbSize,
+            height: thumbSize,
+            size: blob.size,
+        };
+    }
+    /**
+     * Crop an image with specific coordinates
+     * @param file - File or Blob to crop
+     * @param cropData - Crop coordinates and dimensions
+     * @param options - Optional compression options for output
+     * @returns Promise with cropped image
+     */
+    async crop(file, cropData, options) {
+        const img = await this.loadImage(file);
+        const opts = {
+            quality: options?.quality ?? IMAGE_DEFAULTS.quality,
+            mimeType: options?.mimeType ?? IMAGE_DEFAULTS.mimeType,
+        };
+        const canvas = document.createElement('canvas');
+        canvas.width = cropData.width;
+        canvas.height = cropData.height;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, cropData.x, cropData.y, cropData.width, cropData.height, 0, 0, cropData.width, cropData.height);
+        // Apply max dimensions if specified
+        if (options?.maxWidth || options?.maxHeight) {
+            return this.compress(await this.canvasToBlob(canvas, opts.mimeType, 1), options);
+        }
+        const blob = await this.canvasToBlob(canvas, opts.mimeType, opts.quality);
+        const dataUrl = canvas.toDataURL(opts.mimeType, opts.quality);
+        return {
+            blob,
+            dataUrl,
+            width: cropData.width,
+            height: cropData.height,
+            size: blob.size,
+        };
+    }
+    /**
+     * Validate an image file before processing
+     * @param file - File to validate
+     * @param options - Validation options
+     * @returns Validation result with error details if invalid
+     */
+    validate(file, options) {
+        const opts = {
+            maxSize: options?.maxSize ?? IMAGE_DEFAULTS.maxSize,
+            allowedTypes: options?.allowedTypes ?? IMAGE_DEFAULTS.allowedTypes,
+        };
+        // Check file type
+        if (!opts.allowedTypes.includes(file.type)) {
+            return {
+                valid: false,
+                error: 'invalidType',
+                message: `Formato no válido. Usa: ${opts.allowedTypes.map(t => t.split('/')[1].toUpperCase()).join(', ')}`,
+            };
+        }
+        // Check file size
+        if (file.size > opts.maxSize) {
+            const maxMB = Math.round(opts.maxSize / (1024 * 1024));
+            return {
+                valid: false,
+                error: 'fileTooLarge',
+                message: `La imagen es muy grande. Máximo ${maxMB}MB`,
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Validate image dimensions (async - requires loading image)
+     * @param file - File to validate
+     * @param options - Validation options with minWidth/minHeight
+     * @returns Promise with validation result
+     */
+    async validateDimensions(file, options) {
+        const img = await this.loadImage(file);
+        if (options.minWidth && img.width < options.minWidth) {
+            return {
+                valid: false,
+                error: 'imageTooSmall',
+                message: `La imagen debe tener al menos ${options.minWidth}px de ancho`,
+            };
+        }
+        if (options.minHeight && img.height < options.minHeight) {
+            return {
+                valid: false,
+                error: 'imageTooSmall',
+                message: `La imagen debe tener al menos ${options.minHeight}px de alto`,
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Convert a Blob/File to a data URL
+     */
+    async toDataUrl(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(file);
+        });
+    }
+    /**
+     * Convert a data URL to a Blob
+     */
+    dataUrlToBlob(dataUrl) {
+        const arr = dataUrl.split(',');
+        const mime = arr[0].match(/:(.*?);/)[1];
+        const bstr = atob(arr[1]);
+        let n = bstr.length;
+        const u8arr = new Uint8Array(n);
+        while (n--) {
+            u8arr[n] = bstr.charCodeAt(n);
+        }
+        return new Blob([u8arr], { type: mime });
+    }
+    // ============== Private Helpers ==============
+    loadImage(file) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                URL.revokeObjectURL(img.src);
+                resolve(img);
+            };
+            img.onerror = reject;
+            img.src = URL.createObjectURL(file);
+        });
+    }
+    calculateDimensions(originalWidth, originalHeight, maxWidth, maxHeight) {
+        let width = originalWidth;
+        let height = originalHeight;
+        // Scale down if necessary, maintaining aspect ratio
+        if (width > maxWidth) {
+            height = (height * maxWidth) / width;
+            width = maxWidth;
+        }
+        if (height > maxHeight) {
+            width = (width * maxHeight) / height;
+            height = maxHeight;
+        }
+        return {
+            width: Math.round(width),
+            height: Math.round(height),
+        };
+    }
+    canvasToBlob(canvas, mimeType, quality) {
+        return new Promise((resolve, reject) => {
+            canvas.toBlob((blob) => {
+                if (blob)
+                    resolve(blob);
+                else
+                    reject(new Error('Failed to create blob from canvas'));
+            }, mimeType, quality);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ImageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ImageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/image/image.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CropData,\n  IMAGE_DEFAULTS,\n  ImageCompressOptions,\n  ImageValidateOptions,\n  ImageValidationResult,\n  ProcessedImage,\n} from './types';\n\n/**\n * ImageService\n *\n * Service for image processing including compression, thumbnails, cropping and validation.\n * Uses HTML Canvas for all operations - no external dependencies.\n *\n * @example\n * ```typescript\n * const imageService = inject(ImageService);\n *\n * // Compress an image\n * const compressed = await imageService.compress(file, { maxWidth: 800, quality: 0.8 });\n *\n * // Generate thumbnail\n * const thumb = await imageService.thumbnail(file, 150);\n *\n * // Validate before processing\n * const validation = imageService.validate(file, { maxSize: 5 * 1024 * 1024 });\n * if (!validation.valid) {\n *   console.error(validation.message);\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class ImageService {\n  /**\n   * Compress an image maintaining aspect ratio\n   * @param file - File or Blob to compress\n   * @param options - Compression options\n   * @returns Promise with processed image data\n   */\n  async compress(\n    file: File | Blob,\n    options?: ImageCompressOptions\n  ): Promise<ProcessedImage> {\n    const opts = {\n      maxWidth: options?.maxWidth ?? IMAGE_DEFAULTS.maxWidth,\n      maxHeight: options?.maxHeight ?? IMAGE_DEFAULTS.maxHeight,\n      quality: options?.quality ?? IMAGE_DEFAULTS.quality,\n      mimeType: options?.mimeType ?? IMAGE_DEFAULTS.mimeType,\n    };\n\n    const img = await this.loadImage(file);\n    const { width, height } = this.calculateDimensions(\n      img.width,\n      img.height,\n      opts.maxWidth,\n      opts.maxHeight\n    );\n\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n\n    const ctx = canvas.getContext('2d')!;\n    ctx.drawImage(img, 0, 0, width, height);\n\n    const blob = await this.canvasToBlob(canvas, opts.mimeType, opts.quality);\n    const dataUrl = canvas.toDataURL(opts.mimeType, opts.quality);\n\n    return {\n      blob,\n      dataUrl,\n      width,\n      height,\n      size: blob.size,\n    };\n  }\n\n  /**\n   * Generate a square thumbnail from an image\n   * @param file - File or Blob to process\n   * @param size - Thumbnail size in pixels (default: 150)\n   * @returns Promise with processed thumbnail\n   */\n  async thumbnail(file: File | Blob, size?: number): Promise<ProcessedImage> {\n    const thumbSize = size ?? IMAGE_DEFAULTS.thumbnailSize;\n    const img = await this.loadImage(file);\n\n    // Calculate square crop from center\n    const minDim = Math.min(img.width, img.height);\n    const cropX = (img.width - minDim) / 2;\n    const cropY = (img.height - minDim) / 2;\n\n    const canvas = document.createElement('canvas');\n    canvas.width = thumbSize;\n    canvas.height = thumbSize;\n\n    const ctx = canvas.getContext('2d')!;\n    ctx.drawImage(\n      img,\n      cropX,\n      cropY,\n      minDim,\n      minDim,\n      0,\n      0,\n      thumbSize,\n      thumbSize\n    );\n\n    const blob = await this.canvasToBlob(\n      canvas,\n      IMAGE_DEFAULTS.mimeType,\n      0.7 // Lower quality for thumbnails\n    );\n    const dataUrl = canvas.toDataURL(IMAGE_DEFAULTS.mimeType, 0.7);\n\n    return {\n      blob,\n      dataUrl,\n      width: thumbSize,\n      height: thumbSize,\n      size: blob.size,\n    };\n  }\n\n  /**\n   * Crop an image with specific coordinates\n   * @param file - File or Blob to crop\n   * @param cropData - Crop coordinates and dimensions\n   * @param options - Optional compression options for output\n   * @returns Promise with cropped image\n   */\n  async crop(\n    file: File | Blob,\n    cropData: CropData,\n    options?: ImageCompressOptions\n  ): Promise<ProcessedImage> {\n    const img = await this.loadImage(file);\n    const opts = {\n      quality: options?.quality ?? IMAGE_DEFAULTS.quality,\n      mimeType: options?.mimeType ?? IMAGE_DEFAULTS.mimeType,\n    };\n\n    const canvas = document.createElement('canvas');\n    canvas.width = cropData.width;\n    canvas.height = cropData.height;\n\n    const ctx = canvas.getContext('2d')!;\n    ctx.drawImage(\n      img,\n      cropData.x,\n      cropData.y,\n      cropData.width,\n      cropData.height,\n      0,\n      0,\n      cropData.width,\n      cropData.height\n    );\n\n    // Apply max dimensions if specified\n    if (options?.maxWidth || options?.maxHeight) {\n      return this.compress(await this.canvasToBlob(canvas, opts.mimeType, 1), options);\n    }\n\n    const blob = await this.canvasToBlob(canvas, opts.mimeType, opts.quality);\n    const dataUrl = canvas.toDataURL(opts.mimeType, opts.quality);\n\n    return {\n      blob,\n      dataUrl,\n      width: cropData.width,\n      height: cropData.height,\n      size: blob.size,\n    };\n  }\n\n  /**\n   * Validate an image file before processing\n   * @param file - File to validate\n   * @param options - Validation options\n   * @returns Validation result with error details if invalid\n   */\n  validate(file: File, options?: ImageValidateOptions): ImageValidationResult {\n    const opts = {\n      maxSize: options?.maxSize ?? IMAGE_DEFAULTS.maxSize,\n      allowedTypes: options?.allowedTypes ?? IMAGE_DEFAULTS.allowedTypes,\n    };\n\n    // Check file type\n    if (!opts.allowedTypes.includes(file.type)) {\n      return {\n        valid: false,\n        error: 'invalidType',\n        message: `Formato no válido. Usa: ${opts.allowedTypes.map(t => t.split('/')[1].toUpperCase()).join(', ')}`,\n      };\n    }\n\n    // Check file size\n    if (file.size > opts.maxSize) {\n      const maxMB = Math.round(opts.maxSize / (1024 * 1024));\n      return {\n        valid: false,\n        error: 'fileTooLarge',\n        message: `La imagen es muy grande. Máximo ${maxMB}MB`,\n      };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Validate image dimensions (async - requires loading image)\n   * @param file - File to validate\n   * @param options - Validation options with minWidth/minHeight\n   * @returns Promise with validation result\n   */\n  async validateDimensions(\n    file: File,\n    options: Pick<ImageValidateOptions, 'minWidth' | 'minHeight'>\n  ): Promise<ImageValidationResult> {\n    const img = await this.loadImage(file);\n\n    if (options.minWidth && img.width < options.minWidth) {\n      return {\n        valid: false,\n        error: 'imageTooSmall',\n        message: `La imagen debe tener al menos ${options.minWidth}px de ancho`,\n      };\n    }\n\n    if (options.minHeight && img.height < options.minHeight) {\n      return {\n        valid: false,\n        error: 'imageTooSmall',\n        message: `La imagen debe tener al menos ${options.minHeight}px de alto`,\n      };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Convert a Blob/File to a data URL\n   */\n  async toDataUrl(file: File | Blob): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const reader = new FileReader();\n      reader.onload = () => resolve(reader.result as string);\n      reader.onerror = reject;\n      reader.readAsDataURL(file);\n    });\n  }\n\n  /**\n   * Convert a data URL to a Blob\n   */\n  dataUrlToBlob(dataUrl: string): Blob {\n    const arr = dataUrl.split(',');\n    const mime = arr[0].match(/:(.*?);/)![1];\n    const bstr = atob(arr[1]);\n    let n = bstr.length;\n    const u8arr = new Uint8Array(n);\n    while (n--) {\n      u8arr[n] = bstr.charCodeAt(n);\n    }\n    return new Blob([u8arr], { type: mime });\n  }\n\n  // ============== Private Helpers ==============\n\n  private loadImage(file: File | Blob): Promise<HTMLImageElement> {\n    return new Promise((resolve, reject) => {\n      const img = new Image();\n      img.onload = () => {\n        URL.revokeObjectURL(img.src);\n        resolve(img);\n      };\n      img.onerror = reject;\n      img.src = URL.createObjectURL(file);\n    });\n  }\n\n  private calculateDimensions(\n    originalWidth: number,\n    originalHeight: number,\n    maxWidth: number,\n    maxHeight: number\n  ): { width: number; height: number } {\n    let width = originalWidth;\n    let height = originalHeight;\n\n    // Scale down if necessary, maintaining aspect ratio\n    if (width > maxWidth) {\n      height = (height * maxWidth) / width;\n      width = maxWidth;\n    }\n\n    if (height > maxHeight) {\n      width = (width * maxHeight) / height;\n      height = maxHeight;\n    }\n\n    return {\n      width: Math.round(width),\n      height: Math.round(height),\n    };\n  }\n\n  private canvasToBlob(\n    canvas: HTMLCanvasElement,\n    mimeType: string,\n    quality: number\n  ): Promise<Blob> {\n    return new Promise((resolve, reject) => {\n      canvas.toBlob(\n        (blob) => {\n          if (blob) resolve(blob);\n          else reject(new Error('Failed to create blob from canvas'));\n        },\n        mimeType,\n        quality\n      );\n    });\n  }\n}\n"]}

package/esm2022/lib/services/image/index.mjs

@@ -0,0 +1,3 @@
+export * from './image.service';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2ltYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ltYWdlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/esm2022/lib/services/image/types.mjs

@@ -0,0 +1,13 @@
+/**
+ * Default values for image processing
+ */
+export const IMAGE_DEFAULTS = {
+    maxWidth: 800,
+    maxHeight: 800,
+    quality: 0.8,
+    mimeType: 'image/jpeg',
+    maxSize: 10 * 1024 * 1024, // 10MB
+    allowedTypes: ['image/jpeg', 'image/png', 'image/webp', 'image/gif'],
+    thumbnailSize: 150,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/in-app-browser.service.mjs

@@ -0,0 +1,35 @@
+/* eslint-disable no-underscore-dangle */
+/**
+ * Service for opening URLs using Capacitor's InAppBrowser plugin.
+ * Provides a method to open links in a popover-style browser within the app.
+ */
+import { Injectable } from '@angular/core';
+import { Browser } from '@capacitor/browser';
+import * as i0 from "@angular/core";
+export class InAppBrowserService {
+    constructor() {
+        /**
+         * Default options for the in-app browser.
+         */
+        this.options = {
+            presentationStyle: 'popover',
+            url: '',
+        };
+    }
+    /**
+     * Opens a URL using Capacitor's InAppBrowser with the configured options.
+     * @param url The URL to open
+     */
+    async openWithInAppBrowser(url) {
+        await Browser.open({ ...this.options, url });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InAppBrowserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InAppBrowserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InAppBrowserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW4tYXBwLWJyb3dzZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvaW4tYXBwLWJyb3dzZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx5Q0FBeUM7QUFFekM7OztHQUdHO0FBQ0gsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFlLE1BQU0sb0JBQW9CLENBQUM7O0FBSzFELE1BQU0sT0FBTyxtQkFBbUI7SUFROUI7UUFQQTs7V0FFRztRQUNILFlBQU8sR0FBZ0I7WUFDckIsaUJBQWlCLEVBQUUsU0FBUztZQUM1QixHQUFHLEVBQUUsRUFBRTtTQUNSLENBQUM7SUFDYSxDQUFDO0lBRWhCOzs7T0FHRztJQUNILEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxHQUFXO1FBQ3BDLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLEdBQUcsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQy9DLENBQUM7K0dBaEJVLG1CQUFtQjttSEFBbkIsbUJBQW1CLGNBRmxCLE1BQU07OzRGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBuby11bmRlcnNjb3JlLWRhbmdsZSAqL1xuXG4vKipcbiAqIFNlcnZpY2UgZm9yIG9wZW5pbmcgVVJMcyB1c2luZyBDYXBhY2l0b3IncyBJbkFwcEJyb3dzZXIgcGx1Z2luLlxuICogUHJvdmlkZXMgYSBtZXRob2QgdG8gb3BlbiBsaW5rcyBpbiBhIHBvcG92ZXItc3R5bGUgYnJvd3NlciB3aXRoaW4gdGhlIGFwcC5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQnJvd3NlciwgT3Blbk9wdGlvbnMgfSBmcm9tICdAY2FwYWNpdG9yL2Jyb3dzZXInO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgSW5BcHBCcm93c2VyU2VydmljZSB7XG4gIC8qKlxuICAgKiBEZWZhdWx0IG9wdGlvbnMgZm9yIHRoZSBpbi1hcHAgYnJvd3Nlci5cbiAgICovXG4gIG9wdGlvbnM6IE9wZW5PcHRpb25zID0ge1xuICAgIHByZXNlbnRhdGlvblN0eWxlOiAncG9wb3ZlcicsXG4gICAgdXJsOiAnJyxcbiAgfTtcbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIC8qKlxuICAgKiBPcGVucyBhIFVSTCB1c2luZyBDYXBhY2l0b3IncyBJbkFwcEJyb3dzZXIgd2l0aCB0aGUgY29uZmlndXJlZCBvcHRpb25zLlxuICAgKiBAcGFyYW0gdXJsIFRoZSBVUkwgdG8gb3BlblxuICAgKi9cbiAgYXN5bmMgb3BlbldpdGhJbkFwcEJyb3dzZXIodXJsOiBzdHJpbmcpIHtcbiAgICBhd2FpdCBCcm93c2VyLm9wZW4oeyAuLi50aGlzLm9wdGlvbnMsIHVybCB9KTtcbiAgfVxufVxuIl19

package/esm2022/lib/services/legal-link/legal-link.service.mjs

@@ -0,0 +1,85 @@
+import { InjectionToken, Injectable, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export const VALTECH_LEGAL_CONFIG = new InjectionToken('VALTECH_LEGAL_CONFIG');
+/**
+ * Resolves legal/site paths against a configurable main-site base URL.
+ *
+ * - **Main site mode**: no `provideValtechLegal` called → `resolve('/legal/terms')` returns `/legal/terms` (relative).
+ * - **Satellite mode**: `provideValtechLegal({ baseUrl: 'https://myvaltech.com' })` → `resolve('/legal/terms')` returns `'https://myvaltech.com/legal/terms'` and `isExternal('/legal/terms')` returns `true`.
+ *
+ * Absolute URLs passed in are returned unchanged (no double-prefix).
+ */
+export class LegalLinkService {
+    constructor() {
+        this.config = inject(VALTECH_LEGAL_CONFIG, { optional: true }) ?? {};
+    }
+    /** Effective base URL (null if running as main site). */
+    get baseUrl() {
+        return this.config.baseUrl?.replace(/\/$/, '') ?? null;
+    }
+    /** Whether resolved external links should open in a new tab. */
+    get openInNewTab() {
+        return this.config.openInNewTab ?? Boolean(this.config.baseUrl);
+    }
+    /**
+     * Returns the URL to use for a given internal path. Absolute URLs pass through.
+     *
+     * When `locale` is provided AND the resolved URL would be cross-origin, appends
+     * `?lang={locale}` so the main site can render the legal doc in the user's
+     * active language (instead of its default). Locale is omitted for same-origin
+     * resolves since the main site reads locale from its own `LocaleService`.
+     *
+     * @example
+     * resolve('/legal/terms')
+     *   // main site:  '/legal/terms'
+     *   // satellite:  'https://myvaltech.com/legal/terms'
+     *
+     * resolve('/legal/terms', { locale: 'pt' })
+     *   // main site:  '/legal/terms'  (locale stays implicit)
+     *   // satellite:  'https://myvaltech.com/legal/terms?lang=pt'
+     *
+     * resolve('https://x.com/y') // unchanged
+     */
+    resolve(path, options) {
+        if (!path)
+            return path;
+        if (/^https?:\/\//i.test(path))
+            return path;
+        const base = this.baseUrl;
+        if (!base)
+            return path;
+        const url = `${base}${path.startsWith('/') ? '' : '/'}${path}`;
+        if (options?.locale) {
+            const sep = url.includes('?') ? '&' : '?';
+            return `${url}${sep}lang=${encodeURIComponent(options.locale)}`;
+        }
+        return url;
+    }
+    /** `true` if the path would be resolved to a cross-origin URL. */
+    isExternal(path) {
+        if (/^https?:\/\//i.test(path))
+            return true;
+        return this.baseUrl !== null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalLinkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalLinkService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalLinkService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Wires `LegalLinkService` for satellite apps. Omit in the main site (the one
+ * that hosts the canonical /legal/* routes) so links stay relative.
+ *
+ * @example
+ * // main.ts of showcase / sigify / etc.
+ * provideValtechLegal({
+ *   baseUrl: 'https://myvaltech.com',
+ *   openInNewTab: true,
+ * }),
+ */
+export function provideValtechLegal(config) {
+    return { provide: VALTECH_LEGAL_CONFIG, useValue: config };
+}
+//# sourceMappingURL=data:application/json;base64,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