valtech-components 2.0.821 → 2.0.824

package/esm2022/lib/shared/pipes/process-links.pipe.mjs

@@ -0,0 +1,69 @@
+import { Pipe, inject } from '@angular/core';
+import { LinkProcessorService } from '../../services/link-processor.service';
+import * as i0 from "@angular/core";
+/**
+ * ProcessLinksPipe - Pipe para procesar texto y convertir URLs en enlaces clickeables.
+ *
+ * Este pipe standalone detecta automáticamente URLs externas (http/https) y rutas internas
+ * (que empiezan con /) y las convierte en elementos HTML anchor con los atributos apropiados.
+ *
+ * @example Uso básico:
+ * ```html
+ * <div [innerHTML]="'Visit https://example.com or go to /profile' | processLinks"></div>
+ * ```
+ *
+ * @example Con configuración personalizada:
+ * ```html
+ * <div [innerHTML]="text | processLinks:linkConfig"></div>
+ * ```
+ *
+ * @example En TypeScript:
+ * ```typescript
+ * export class MyComponent {
+ *   linkConfig: LinkProcessorConfig = {
+ *     openExternalInNewTab: true,
+ *     openInternalInNewTab: false,
+ *     linkClass: 'my-link',
+ *     externalLinkClass: 'external',
+ *     internalLinkClass: 'internal'
+ *   };
+ * }
+ * ```
+ */
+export class ProcessLinksPipe {
+    constructor() {
+        this.linkProcessor = inject(LinkProcessorService);
+    }
+    /**
+     * Transforma texto procesando URLs y rutas internas para convertirlas en enlaces.
+     *
+     * @param value - El texto a procesar
+     * @param config - Configuración opcional para el procesamiento de enlaces
+     * @returns SafeHtml con enlaces procesados o string original si no hay enlaces
+     *
+     * @example
+     * ```html
+     * <!-- Uso básico -->
+     * <p [innerHTML]="'Check out https://angular.io' | processLinks"></p>
+     *
+     * <!-- Con configuración -->
+     * <p [innerHTML]="message | processLinks:{ openExternalInNewTab: false }"></p>
+     * ```
+     */
+    transform(value, config) {
+        if (!value) {
+            return '';
+        }
+        return this.linkProcessor.processLinks(value, config);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, isStandalone: true, name: "processLinks" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ProcessLinksPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'processLinks',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/utils/datetime.mjs

@@ -0,0 +1,24 @@
+/**
+ * Returns the i18n key for a time-of-day greeting based on the given date's hour.
+ *
+ * - 00:00 - 11:59 → 'goodMorning'
+ * - 12:00 - 17:59 → 'goodAfternoon'
+ * - 18:00 - 23:59 → 'goodEvening'
+ *
+ * Pure function (testable). Defaults to current local time.
+ *
+ * @example
+ * import { getTimeOfDayKey } from 'valtech-components';
+ *
+ * const key = getTimeOfDayKey();          // 'goodMorning' | 'goodAfternoon' | 'goodEvening'
+ * const text = i18n.t(key);               // 'Buenos días' | 'Buenas tardes' | 'Buenas noches'
+ */
+export function getTimeOfDayKey(date = new Date()) {
+    const hour = date.getHours();
+    if (hour < 12)
+        return 'goodMorning';
+    if (hour < 18)
+        return 'goodAfternoon';
+    return 'goodEvening';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NoYXJlZC91dGlscy9kYXRldGltZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsT0FBYSxJQUFJLElBQUksRUFBRTtJQUNyRCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDN0IsSUFBSSxJQUFJLEdBQUcsRUFBRTtRQUFFLE9BQU8sYUFBYSxDQUFDO0lBQ3BDLElBQUksSUFBSSxHQUFHLEVBQUU7UUFBRSxPQUFPLGVBQWUsQ0FBQztJQUN0QyxPQUFPLGFBQWEsQ0FBQztBQUN2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaW1lLW9mLWRheSBncmVldGluZyBrZXkuXG4gKiBNYXBzIHRvIGJ1bmRsZWQgaTE4biBrZXlzIGluIGBfZ2xvYmFsYCBuYW1lc3BhY2U6IGdvb2RNb3JuaW5nIC8gZ29vZEFmdGVybm9vbiAvIGdvb2RFdmVuaW5nLlxuICovXG5leHBvcnQgdHlwZSBUaW1lT2ZEYXlLZXkgPSAnZ29vZE1vcm5pbmcnIHwgJ2dvb2RBZnRlcm5vb24nIHwgJ2dvb2RFdmVuaW5nJztcblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBpMThuIGtleSBmb3IgYSB0aW1lLW9mLWRheSBncmVldGluZyBiYXNlZCBvbiB0aGUgZ2l2ZW4gZGF0ZSdzIGhvdXIuXG4gKlxuICogLSAwMDowMCAtIDExOjU5IOKGkiAnZ29vZE1vcm5pbmcnXG4gKiAtIDEyOjAwIC0gMTc6NTkg4oaSICdnb29kQWZ0ZXJub29uJ1xuICogLSAxODowMCAtIDIzOjU5IOKGkiAnZ29vZEV2ZW5pbmcnXG4gKlxuICogUHVyZSBmdW5jdGlvbiAodGVzdGFibGUpLiBEZWZhdWx0cyB0byBjdXJyZW50IGxvY2FsIHRpbWUuXG4gKlxuICogQGV4YW1wbGVcbiAqIGltcG9ydCB7IGdldFRpbWVPZkRheUtleSB9IGZyb20gJ3ZhbHRlY2gtY29tcG9uZW50cyc7XG4gKlxuICogY29uc3Qga2V5ID0gZ2V0VGltZU9mRGF5S2V5KCk7ICAgICAgICAgIC8vICdnb29kTW9ybmluZycgfCAnZ29vZEFmdGVybm9vbicgfCAnZ29vZEV2ZW5pbmcnXG4gKiBjb25zdCB0ZXh0ID0gaTE4bi50KGtleSk7ICAgICAgICAgICAgICAgLy8gJ0J1ZW5vcyBkw61hcycgfCAnQnVlbmFzIHRhcmRlcycgfCAnQnVlbmFzIG5vY2hlcydcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFRpbWVPZkRheUtleShkYXRlOiBEYXRlID0gbmV3IERhdGUoKSk6IFRpbWVPZkRheUtleSB7XG4gIGNvbnN0IGhvdXIgPSBkYXRlLmdldEhvdXJzKCk7XG4gIGlmIChob3VyIDwgMTIpIHJldHVybiAnZ29vZE1vcm5pbmcnO1xuICBpZiAoaG91ciA8IDE4KSByZXR1cm4gJ2dvb2RBZnRlcm5vb24nO1xuICByZXR1cm4gJ2dvb2RFdmVuaW5nJztcbn1cbiJdfQ==

package/esm2022/lib/shared/utils/dom.mjs

@@ -0,0 +1,27 @@
+/**
+ * Scrolls smoothly to the top of the element with the given id.
+ * @param id The id of the element to scroll to
+ */
+export const goToTop = (id) => {
+    const element = document.getElementById(id);
+    if (element) {
+        element.scrollIntoView({
+            block: 'start',
+            inline: 'nearest',
+            behavior: 'smooth',
+        });
+    }
+};
+/**
+ * Checks if the bottom of the given ElementRef is within the viewport.
+ * Useful for determining if a form or element is fully visible.
+ * @param elementRef The Angular ElementRef to check
+ * @returns True if the element's bottom is at or above the window's bottom
+ */
+export const isAtEnd = (elementRef) => {
+    const formElement = elementRef.nativeElement;
+    const rect = formElement.getBoundingClientRect();
+    const windowHeight = window.innerHeight;
+    return rect.bottom <= windowHeight;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/utils/form-defaults.mjs

@@ -0,0 +1,112 @@
+/**
+ * Utilities for handling default values in form inputs based on InputMetadata configuration.
+ */
+import { InputType } from '../../components/types';
+/**
+ * Resolves the initial value for a form input based on its configuration.
+ *
+ * @param input - The input metadata configuration
+ * @returns The resolved initial value
+ *
+ * @example
+ * // Custom default value
+ * const customValue = resolveInputDefaultValue({ withDefault: '2025-06-24', type: InputType.DATE });
+ *
+ * // Auto default value
+ * const autoValue = resolveInputDefaultValue({ withDefault: true, type: InputType.NUMBER });
+ *
+ * // Explicit value (takes precedence)
+ * const explicitValue = resolveInputDefaultValue({ value: 'explicit', withDefault: true, type: InputType.TEXT });
+ */
+export function resolveInputDefaultValue(input) {
+    // Explicit value takes precedence
+    if (input.value !== undefined && input.value !== null && input.value !== '') {
+        return parseValueByType(input.value, input.type);
+    }
+    // No default configuration
+    if (!input.withDefault) {
+        return null;
+    }
+    // Custom default value
+    if (typeof input.withDefault === 'string') {
+        return parseValueByType(input.withDefault, input.type);
+    }
+    // Auto default value (withDefault === true)
+    return getAutoDefaultValue(input.type);
+}
+/**
+ * Parses a string value to the appropriate type based on the input type.
+ *
+ * @param value - The string value to parse
+ * @param type - The input type
+ * @returns The parsed value
+ */
+function parseValueByType(value, type) {
+    switch (type) {
+        case InputType.DATE:
+            return new Date(value).toISOString();
+        case InputType.NUMBER:
+            return parseFloat(value) || 0;
+        case InputType.CHECK:
+            return value === 'true' || value === '1';
+        case InputType.TEXT:
+        case InputType.EMAIL:
+        case InputType.PASSWORD:
+        case InputType.COMMENT:
+        case InputType.PIN_CODE:
+        case InputType.HOUR:
+        case InputType.RADIO:
+        case InputType.SELECT:
+        case InputType.SEARCH_SELECT:
+        case InputType.FILE:
+        default:
+            return value;
+    }
+}
+/**
+ * Gets the automatic default value for a given input type.
+ *
+ * @param type - The input type
+ * @returns The auto default value
+ */
+function getAutoDefaultValue(type) {
+    switch (type) {
+        case InputType.DATE:
+            return new Date().toISOString();
+        case InputType.NUMBER:
+            return 0;
+        case InputType.CHECK:
+            return false;
+        case InputType.TEXT:
+        case InputType.EMAIL:
+        case InputType.PASSWORD:
+        case InputType.COMMENT:
+        case InputType.PIN_CODE:
+        case InputType.HOUR:
+        case InputType.RADIO:
+        case InputType.SELECT:
+        case InputType.SEARCH_SELECT:
+        case InputType.FILE:
+        default:
+            return '';
+    }
+}
+/**
+ * Applies the resolved default value to a FormControl.
+ *
+ * @param input - The input metadata configuration
+ * @example
+ * const input = { control: myFormControl, type: InputType.DATE, withDefault: true };
+ * applyDefaultValueToControl(input);
+ */
+export function applyDefaultValueToControl(input) {
+    if (!input.control)
+        return;
+    const defaultValue = resolveInputDefaultValue(input);
+    if (defaultValue !== null) {
+        input.control.setValue(defaultValue);
+        input.control.markAsPristine();
+        input.control.updateValueAndValidity();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/utils/styles.mjs

@@ -0,0 +1,37 @@
+/**
+ * Resolves a color string to a valid CSS value for use in styles.
+ * Supports Ionic color names, CSS variables, and custom colors.
+ *
+ * @param color The color name, CSS variable, or custom color string
+ * @returns A valid CSS color value
+ *
+ * @example
+ * resolveColor('primary'); // returns 'var(--ion-color-primary)'
+ * resolveColor('--my-custom-color'); // returns 'var(--my-custom-color)'
+ * resolveColor('#ff0000'); // returns '#ff0000'
+ */
+export function resolveColor(color) {
+    // Si el color empieza con "--", se asume que es una variable CSS válida
+    if (color.startsWith('--')) {
+        return `var(${color})`;
+    }
+    // Lista de colores predefinidos de Ionic
+    const ionicColors = [
+        'primary',
+        'secondary',
+        'tertiary',
+        'success',
+        'warning',
+        'danger',
+        'light',
+        'medium',
+        'dark',
+    ];
+    // Verificar si el color es un color de Ionic
+    if (ionicColors.includes(color)) {
+        return `var(--ion-color-${color})`;
+    }
+    // Si no es una variable CSS ni un color de Ionic, devolver el color tal cual
+    return color;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zaGFyZWQvdXRpbHMvc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxLQUFhO0lBQ3hDLHdFQUF3RTtJQUN4RSxJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUMzQixPQUFPLE9BQU8sS0FBSyxHQUFHLENBQUM7SUFDekIsQ0FBQztJQUVELHlDQUF5QztJQUN6QyxNQUFNLFdBQVcsR0FBRztRQUNsQixTQUFTO1FBQ1QsV0FBVztRQUNYLFVBQVU7UUFDVixTQUFTO1FBQ1QsU0FBUztRQUNULFFBQVE7UUFDUixPQUFPO1FBQ1AsUUFBUTtRQUNSLE1BQU07S0FDUCxDQUFDO0lBRUYsNkNBQTZDO0lBQzdDLElBQUksV0FBVyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ2hDLE9BQU8sbUJBQW1CLEtBQUssR0FBRyxDQUFDO0lBQ3JDLENBQUM7SUFFRCw2RUFBNkU7SUFDN0UsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXNvbHZlcyBhIGNvbG9yIHN0cmluZyB0byBhIHZhbGlkIENTUyB2YWx1ZSBmb3IgdXNlIGluIHN0eWxlcy5cbiAqIFN1cHBvcnRzIElvbmljIGNvbG9yIG5hbWVzLCBDU1MgdmFyaWFibGVzLCBhbmQgY3VzdG9tIGNvbG9ycy5cbiAqXG4gKiBAcGFyYW0gY29sb3IgVGhlIGNvbG9yIG5hbWUsIENTUyB2YXJpYWJsZSwgb3IgY3VzdG9tIGNvbG9yIHN0cmluZ1xuICogQHJldHVybnMgQSB2YWxpZCBDU1MgY29sb3IgdmFsdWVcbiAqXG4gKiBAZXhhbXBsZVxuICogcmVzb2x2ZUNvbG9yKCdwcmltYXJ5Jyk7IC8vIHJldHVybnMgJ3ZhcigtLWlvbi1jb2xvci1wcmltYXJ5KSdcbiAqIHJlc29sdmVDb2xvcignLS1teS1jdXN0b20tY29sb3InKTsgLy8gcmV0dXJucyAndmFyKC0tbXktY3VzdG9tLWNvbG9yKSdcbiAqIHJlc29sdmVDb2xvcignI2ZmMDAwMCcpOyAvLyByZXR1cm5zICcjZmYwMDAwJ1xuICovXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZUNvbG9yKGNvbG9yOiBzdHJpbmcpOiBzdHJpbmcge1xuICAvLyBTaSBlbCBjb2xvciBlbXBpZXphIGNvbiBcIi0tXCIsIHNlIGFzdW1lIHF1ZSBlcyB1bmEgdmFyaWFibGUgQ1NTIHbDoWxpZGFcbiAgaWYgKGNvbG9yLnN0YXJ0c1dpdGgoJy0tJykpIHtcbiAgICByZXR1cm4gYHZhcigke2NvbG9yfSlgO1xuICB9XG5cbiAgLy8gTGlzdGEgZGUgY29sb3JlcyBwcmVkZWZpbmlkb3MgZGUgSW9uaWNcbiAgY29uc3QgaW9uaWNDb2xvcnMgPSBbXG4gICAgJ3ByaW1hcnknLFxuICAgICdzZWNvbmRhcnknLFxuICAgICd0ZXJ0aWFyeScsXG4gICAgJ3N1Y2Nlc3MnLFxuICAgICd3YXJuaW5nJyxcbiAgICAnZGFuZ2VyJyxcbiAgICAnbGlnaHQnLFxuICAgICdtZWRpdW0nLFxuICAgICdkYXJrJyxcbiAgXTtcblxuICAvLyBWZXJpZmljYXIgc2kgZWwgY29sb3IgZXMgdW4gY29sb3IgZGUgSW9uaWNcbiAgaWYgKGlvbmljQ29sb3JzLmluY2x1ZGVzKGNvbG9yKSkge1xuICAgIHJldHVybiBgdmFyKC0taW9uLWNvbG9yLSR7Y29sb3J9KWA7XG4gIH1cblxuICAvLyBTaSBubyBlcyB1bmEgdmFyaWFibGUgQ1NTIG5pIHVuIGNvbG9yIGRlIElvbmljLCBkZXZvbHZlciBlbCBjb2xvciB0YWwgY3VhbFxuICByZXR1cm4gY29sb3I7XG59XG4iXX0=

package/esm2022/lib/shared/utils/text.mjs

@@ -0,0 +1,12 @@
+/**
+ * Removes diacritical marks (accents) from a string using Unicode normalization.
+ * Useful for text search and comparison.
+ *
+ * @param text The input string
+ * @returns The normalized string without diacritical marks
+ *
+ * @example
+ * replaceSpecialChars('canción') // returns 'cancion'
+ */
+export const replaceSpecialChars = (text) => text.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2hhcmVkL3V0aWxzL3RleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUNsRCxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVtb3ZlcyBkaWFjcml0aWNhbCBtYXJrcyAoYWNjZW50cykgZnJvbSBhIHN0cmluZyB1c2luZyBVbmljb2RlIG5vcm1hbGl6YXRpb24uXG4gKiBVc2VmdWwgZm9yIHRleHQgc2VhcmNoIGFuZCBjb21wYXJpc29uLlxuICpcbiAqIEBwYXJhbSB0ZXh0IFRoZSBpbnB1dCBzdHJpbmdcbiAqIEByZXR1cm5zIFRoZSBub3JtYWxpemVkIHN0cmluZyB3aXRob3V0IGRpYWNyaXRpY2FsIG1hcmtzXG4gKlxuICogQGV4YW1wbGVcbiAqIHJlcGxhY2VTcGVjaWFsQ2hhcnMoJ2NhbmNpw7NuJykgLy8gcmV0dXJucyAnY2FuY2lvbidcbiAqL1xuZXhwb3J0IGNvbnN0IHJlcGxhY2VTcGVjaWFsQ2hhcnMgPSAodGV4dDogc3RyaW5nKSA9PlxuICB0ZXh0Lm5vcm1hbGl6ZSgnTkZEJykucmVwbGFjZSgvW1xcdTAzMDAtXFx1MDM2Zl0vZywgJycpO1xuIl19

package/esm2022/lib/version.mjs

@@ -0,0 +1,6 @@
+/**
+ * Current version of valtech-components.
+ * This is automatically updated during the publish process.
+ */
+export const VERSION = '2.0.824';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC44MjQnO1xuIl19