@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/strategies/default-formatters.mjs

@@ -0,0 +1,238 @@
+/**
+ * Default formatter implementations
+ */
+import { isNullOrUndefined, isValidDate } from '../models/cell-types';
+/**
+ * String formatter - default string display
+ */
+export class StringFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value)) {
+            return '';
+        }
+        let result = String(value);
+        if (this.options?.trim) {
+            result = result.trim();
+        }
+        if (this.options?.toUpperCase) {
+            result = result.toUpperCase();
+        }
+        if (this.options?.toLowerCase) {
+            result = result.toLowerCase();
+        }
+        if (this.options?.maxLength && result.length > this.options.maxLength) {
+            const ellipsis = this.options.ellipsis ?? '...';
+            result = result.substring(0, this.options.maxLength - ellipsis.length) + ellipsis;
+        }
+        return result;
+    }
+}
+/**
+ * Number formatter - formats numbers with decimals
+ */
+export class NumberFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value) || isNaN(value)) {
+            return '';
+        }
+        const decimals = this.options?.decimals ?? 2;
+        const fixed = value.toFixed(decimals);
+        const [integerPart, decimalPart] = fixed.split('.');
+        // Add thousands separator
+        const thousandsSeparator = this.options?.thousandsSeparator ?? ',';
+        const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSeparator);
+        // Combine integer and decimal parts
+        const decimalSeparator = this.options?.decimalSeparator ?? '.';
+        const result = decimalPart ? `${formattedInteger}${decimalSeparator}${decimalPart}` : formattedInteger;
+        // Add prefix and suffix
+        const prefix = this.options?.prefix ?? '';
+        const suffix = this.options?.suffix ?? '';
+        return `${prefix}${result}${suffix}`;
+    }
+}
+/**
+ * Currency formatter - formats currency values
+ */
+export class CurrencyFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value) || isNaN(value)) {
+            return '';
+        }
+        const locale = this.options?.locale ?? 'en-US';
+        const currency = this.options?.currency ?? 'USD';
+        const decimals = this.options?.decimals ?? 2;
+        try {
+            return new Intl.NumberFormat(locale, {
+                style: 'currency',
+                currency,
+                minimumFractionDigits: decimals,
+                maximumFractionDigits: decimals
+            }).format(value);
+        }
+        catch (error) {
+            // Fallback if Intl is not supported
+            return `$${value.toFixed(decimals)}`;
+        }
+    }
+}
+/**
+ * Percentage formatter
+ */
+export class PercentageFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value) || isNaN(value)) {
+            return '';
+        }
+        const decimals = this.options?.decimals ?? 2;
+        const multiplier = this.options?.multiplier ?? 1;
+        const percentage = value * multiplier;
+        return `${percentage.toFixed(decimals)}%`;
+    }
+}
+/**
+ * Date formatter - locale-aware date formatting
+ */
+export class DateFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value)) {
+            return '';
+        }
+        // Convert to Date if it's a string or number
+        let date;
+        if (value instanceof Date) {
+            date = value;
+        }
+        else {
+            date = new Date(value);
+        }
+        if (!isValidDate(date)) {
+            return '';
+        }
+        const locale = this.options?.locale ?? 'en-US';
+        try {
+            if (this.options?.format) {
+                return this.formatCustom(date);
+            }
+            return new Intl.DateTimeFormat(locale, {
+                dateStyle: this.options?.dateStyle ?? 'medium',
+                timeStyle: this.options?.timeStyle
+            }).format(date);
+        }
+        catch (error) {
+            return date.toLocaleDateString();
+        }
+    }
+    formatCustom(date) {
+        // Simple custom formatting (can be extended)
+        const format = this.options?.format ?? 'YYYY-MM-DD';
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        return format
+            .replace('YYYY', String(year))
+            .replace('MM', month)
+            .replace('DD', day)
+            .replace('HH', hours)
+            .replace('mm', minutes)
+            .replace('ss', seconds);
+    }
+}
+/**
+ * Boolean formatter - formats boolean values
+ */
+export class BooleanFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value)) {
+            return this.options?.nullValue ?? '';
+        }
+        return value
+            ? (this.options?.trueValue ?? 'Yes')
+            : (this.options?.falseValue ?? 'No');
+    }
+}
+/**
+ * Array formatter - formats array values
+ */
+export class ArrayFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    format(value) {
+        if (isNullOrUndefined(value) || !Array.isArray(value)) {
+            return '';
+        }
+        if (value.length === 0) {
+            return '';
+        }
+        const separator = this.options?.separator ?? ', ';
+        const maxItems = this.options?.maxItems;
+        const itemFormatter = this.options?.itemFormatter ?? ((item) => String(item));
+        let items = value.map(itemFormatter);
+        if (maxItems && items.length > maxItems) {
+            const ellipsis = this.options?.ellipsis ?? '...';
+            items = items.slice(0, maxItems);
+            items.push(ellipsis);
+        }
+        return items.join(separator);
+    }
+}
+/**
+ * Template formatter - formats values using a template string
+ */
+export class TemplateFormatter {
+    constructor(template) {
+        this.template = template;
+    }
+    format(value) {
+        if (isNullOrUndefined(value)) {
+            return '';
+        }
+        return this.template.replace(/\{(\w+)\}/g, (match, key) => {
+            return value[key] ?? match;
+        });
+    }
+}
+/**
+ * Function formatter - formats values using a custom function
+ */
+export class FunctionFormatter {
+    constructor(formatFn) {
+        this.formatFn = formatFn;
+    }
+    format(value) {
+        return this.formatFn(value);
+    }
+}
+/**
+ * Default formatter - returns string representation
+ */
+export class DefaultFormatter {
+    format(value) {
+        if (isNullOrUndefined(value)) {
+            return '';
+        }
+        return String(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-formatters.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/strategies/default-formatters.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Default formatter implementations\n */\n\nimport { CellFormatter } from '../models/cell-strategies.interface';\nimport { isNullOrUndefined, isValidDate } from '../models/cell-types';\n\n/**\n * String formatter - default string display\n */\nexport class StringFormatter implements CellFormatter<string> {\n  constructor(\n    private readonly options?: {\n      maxLength?: number;\n      ellipsis?: string;\n      trim?: boolean;\n      toUpperCase?: boolean;\n      toLowerCase?: boolean;\n    }\n  ) {}\n\n  format(value: string): string {\n    if (isNullOrUndefined(value)) {\n      return '';\n    }\n\n    let result = String(value);\n\n    if (this.options?.trim) {\n      result = result.trim();\n    }\n\n    if (this.options?.toUpperCase) {\n      result = result.toUpperCase();\n    }\n\n    if (this.options?.toLowerCase) {\n      result = result.toLowerCase();\n    }\n\n    if (this.options?.maxLength && result.length > this.options.maxLength) {\n      const ellipsis = this.options.ellipsis ?? '...';\n      result = result.substring(0, this.options.maxLength - ellipsis.length) + ellipsis;\n    }\n\n    return result;\n  }\n}\n\n/**\n * Number formatter - formats numbers with decimals\n */\nexport class NumberFormatter implements CellFormatter<number> {\n  constructor(\n    private readonly options?: {\n      decimals?: number;\n      thousandsSeparator?: string;\n      decimalSeparator?: string;\n      prefix?: string;\n      suffix?: string;\n    }\n  ) {}\n\n  format(value: number): string {\n    if (isNullOrUndefined(value) || isNaN(value)) {\n      return '';\n    }\n\n    const decimals = this.options?.decimals ?? 2;\n    const fixed = value.toFixed(decimals);\n    \n    const [integerPart, decimalPart] = fixed.split('.');\n    \n    // Add thousands separator\n    const thousandsSeparator = this.options?.thousandsSeparator ?? ',';\n    const formattedInteger = integerPart.replace(/\\B(?=(\\d{3})+(?!\\d))/g, thousandsSeparator);\n    \n    // Combine integer and decimal parts\n    const decimalSeparator = this.options?.decimalSeparator ?? '.';\n    const result = decimalPart ? `${formattedInteger}${decimalSeparator}${decimalPart}` : formattedInteger;\n    \n    // Add prefix and suffix\n    const prefix = this.options?.prefix ?? '';\n    const suffix = this.options?.suffix ?? '';\n    \n    return `${prefix}${result}${suffix}`;\n  }\n}\n\n/**\n * Currency formatter - formats currency values\n */\nexport class CurrencyFormatter implements CellFormatter<number> {\n  constructor(\n    private readonly options?: {\n      currency?: string;\n      locale?: string;\n      decimals?: number;\n    }\n  ) {}\n\n  format(value: number): string {\n    if (isNullOrUndefined(value) || isNaN(value)) {\n      return '';\n    }\n\n    const locale = this.options?.locale ?? 'en-US';\n    const currency = this.options?.currency ?? 'USD';\n    const decimals = this.options?.decimals ?? 2;\n\n    try {\n      return new Intl.NumberFormat(locale, {\n        style: 'currency',\n        currency,\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals\n      }).format(value);\n    } catch (error) {\n      // Fallback if Intl is not supported\n      return `$${value.toFixed(decimals)}`;\n    }\n  }\n}\n\n/**\n * Percentage formatter\n */\nexport class PercentageFormatter implements CellFormatter<number> {\n  constructor(\n    private readonly options?: {\n      decimals?: number;\n      multiplier?: number; // e.g., 100 if value is 0.25 and should display as 25%\n    }\n  ) {}\n\n  format(value: number): string {\n    if (isNullOrUndefined(value) || isNaN(value)) {\n      return '';\n    }\n\n    const decimals = this.options?.decimals ?? 2;\n    const multiplier = this.options?.multiplier ?? 1;\n    const percentage = value * multiplier;\n\n    return `${percentage.toFixed(decimals)}%`;\n  }\n}\n\n/**\n * Date formatter - locale-aware date formatting\n */\nexport class DateFormatter implements CellFormatter<Date> {\n  constructor(\n    private readonly options?: {\n      locale?: string;\n      dateStyle?: 'full' | 'long' | 'medium' | 'short';\n      timeStyle?: 'full' | 'long' | 'medium' | 'short';\n      format?: string; // Custom format string\n    }\n  ) {}\n\n  format(value: Date): string {\n    if (isNullOrUndefined(value)) {\n      return '';\n    }\n\n    // Convert to Date if it's a string or number\n    let date: Date;\n    if (value instanceof Date) {\n      date = value;\n    } else {\n      date = new Date(value);\n    }\n\n    if (!isValidDate(date)) {\n      return '';\n    }\n\n    const locale = this.options?.locale ?? 'en-US';\n\n    try {\n      if (this.options?.format) {\n        return this.formatCustom(date);\n      }\n\n      return new Intl.DateTimeFormat(locale, {\n        dateStyle: this.options?.dateStyle ?? 'medium',\n        timeStyle: this.options?.timeStyle\n      }).format(date);\n    } catch (error) {\n      return date.toLocaleDateString();\n    }\n  }\n\n  private formatCustom(date: Date): string {\n    // Simple custom formatting (can be extended)\n    const format = this.options?.format ?? 'YYYY-MM-DD';\n    \n    const year = date.getFullYear();\n    const month = String(date.getMonth() + 1).padStart(2, '0');\n    const day = String(date.getDate()).padStart(2, '0');\n    const hours = String(date.getHours()).padStart(2, '0');\n    const minutes = String(date.getMinutes()).padStart(2, '0');\n    const seconds = String(date.getSeconds()).padStart(2, '0');\n\n    return format\n      .replace('YYYY', String(year))\n      .replace('MM', month)\n      .replace('DD', day)\n      .replace('HH', hours)\n      .replace('mm', minutes)\n      .replace('ss', seconds);\n  }\n}\n\n/**\n * Boolean formatter - formats boolean values\n */\nexport class BooleanFormatter implements CellFormatter<boolean> {\n  constructor(\n    private readonly options?: {\n      trueValue?: string;\n      falseValue?: string;\n      nullValue?: string;\n    }\n  ) {}\n\n  format(value: boolean): string {\n    if (isNullOrUndefined(value)) {\n      return this.options?.nullValue ?? '';\n    }\n\n    return value \n      ? (this.options?.trueValue ?? 'Yes')\n      : (this.options?.falseValue ?? 'No');\n  }\n}\n\n/**\n * Array formatter - formats array values\n */\nexport class ArrayFormatter<T = any> implements CellFormatter<T[]> {\n  constructor(\n    private readonly options?: {\n      separator?: string;\n      maxItems?: number;\n      ellipsis?: string;\n      itemFormatter?: (item: T) => string;\n    }\n  ) {}\n\n  format(value: T[]): string {\n    if (isNullOrUndefined(value) || !Array.isArray(value)) {\n      return '';\n    }\n\n    if (value.length === 0) {\n      return '';\n    }\n\n    const separator = this.options?.separator ?? ', ';\n    const maxItems = this.options?.maxItems;\n    const itemFormatter = this.options?.itemFormatter ?? ((item: T) => String(item));\n\n    let items = value.map(itemFormatter);\n\n    if (maxItems && items.length > maxItems) {\n      const ellipsis = this.options?.ellipsis ?? '...';\n      items = items.slice(0, maxItems);\n      items.push(ellipsis);\n    }\n\n    return items.join(separator);\n  }\n}\n\n/**\n * Template formatter - formats values using a template string\n */\nexport class TemplateFormatter implements CellFormatter<any> {\n  constructor(private readonly template: string) {}\n\n  format(value: any): string {\n    if (isNullOrUndefined(value)) {\n      return '';\n    }\n\n    return this.template.replace(/\\{(\\w+)\\}/g, (match, key) => {\n      return value[key] ?? match;\n    });\n  }\n}\n\n/**\n * Function formatter - formats values using a custom function\n */\nexport class FunctionFormatter<T = any> implements CellFormatter<T> {\n  constructor(private readonly formatFn: (value: T) => string) {}\n\n  format(value: T): string {\n    return this.formatFn(value);\n  }\n}\n\n/**\n * Default formatter - returns string representation\n */\nexport class DefaultFormatter implements CellFormatter<any> {\n  format(value: any): string {\n    if (isNullOrUndefined(value)) {\n      return '';\n    }\n    return String(value);\n  }\n}\n\n"]}

package/esm2020/lib/strategies/default-validators.mjs

@@ -0,0 +1,327 @@
+/**
+ * Default validator implementations
+ */
+import { isNullOrUndefined } from '../models/cell-types';
+/**
+ * Required validator - ensures value is not empty
+ */
+export class RequiredValidator {
+    constructor(customMessage) {
+        this.customMessage = customMessage;
+        this.errorMessage = 'This field is required';
+        if (customMessage) {
+            this.errorMessage = customMessage;
+        }
+    }
+    validate(value) {
+        const isEmpty = isNullOrUndefined(value) ||
+            (typeof value === 'string' && value.trim() === '') ||
+            (Array.isArray(value) && value.length === 0);
+        return {
+            valid: !isEmpty,
+            error: isEmpty ? this.errorMessage : undefined
+        };
+    }
+}
+/**
+ * Range validator - validates numeric range
+ */
+export class RangeValidator {
+    constructor(min, max, customMessage) {
+        this.min = min;
+        this.max = max;
+        this.errorMessage = customMessage ?? this.buildErrorMessage();
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true }; // Use RequiredValidator for required checks
+        }
+        if (typeof value !== 'number' || isNaN(value)) {
+            return {
+                valid: false,
+                error: 'Value must be a number'
+            };
+        }
+        if (this.min !== undefined && value < this.min) {
+            return {
+                valid: false,
+                error: `Value must be at least ${this.min}`
+            };
+        }
+        if (this.max !== undefined && value > this.max) {
+            return {
+                valid: false,
+                error: `Value must be at most ${this.max}`
+            };
+        }
+        return { valid: true };
+    }
+    buildErrorMessage() {
+        if (this.min !== undefined && this.max !== undefined) {
+            return `Value must be between ${this.min} and ${this.max}`;
+        }
+        else if (this.min !== undefined) {
+            return `Value must be at least ${this.min}`;
+        }
+        else if (this.max !== undefined) {
+            return `Value must be at most ${this.max}`;
+        }
+        return 'Invalid value';
+    }
+}
+/**
+ * String length validator
+ */
+export class LengthValidator {
+    constructor(minLength, maxLength, customMessage) {
+        this.minLength = minLength;
+        this.maxLength = maxLength;
+        this.errorMessage = customMessage ?? this.buildErrorMessage();
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true };
+        }
+        const length = String(value).length;
+        if (this.minLength !== undefined && length < this.minLength) {
+            return {
+                valid: false,
+                error: `Minimum length is ${this.minLength} characters`
+            };
+        }
+        if (this.maxLength !== undefined && length > this.maxLength) {
+            return {
+                valid: false,
+                error: `Maximum length is ${this.maxLength} characters`
+            };
+        }
+        return { valid: true };
+    }
+    buildErrorMessage() {
+        if (this.minLength !== undefined && this.maxLength !== undefined) {
+            return `Length must be between ${this.minLength} and ${this.maxLength} characters`;
+        }
+        else if (this.minLength !== undefined) {
+            return `Minimum length is ${this.minLength} characters`;
+        }
+        else if (this.maxLength !== undefined) {
+            return `Maximum length is ${this.maxLength} characters`;
+        }
+        return 'Invalid length';
+    }
+}
+/**
+ * Regex validator - validates against regular expression
+ */
+export class RegexValidator {
+    constructor(pattern, customMessage) {
+        this.pattern = pattern;
+        this.errorMessage = 'Invalid format';
+        if (customMessage) {
+            this.errorMessage = customMessage;
+        }
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true };
+        }
+        const regex = typeof this.pattern === 'string'
+            ? new RegExp(this.pattern)
+            : this.pattern;
+        const isValid = regex.test(String(value));
+        return {
+            valid: isValid,
+            error: isValid ? undefined : this.errorMessage
+        };
+    }
+}
+/**
+ * Email validator
+ */
+export class EmailValidator {
+    constructor(customMessage) {
+        this.errorMessage = 'Invalid email address';
+        this.emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (customMessage) {
+            this.errorMessage = customMessage;
+        }
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true };
+        }
+        const isValid = this.emailPattern.test(String(value));
+        return {
+            valid: isValid,
+            error: isValid ? undefined : this.errorMessage
+        };
+    }
+}
+/**
+ * URL validator
+ */
+export class UrlValidator {
+    constructor(customMessage) {
+        this.errorMessage = 'Invalid URL';
+        if (customMessage) {
+            this.errorMessage = customMessage;
+        }
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true };
+        }
+        try {
+            new URL(String(value));
+            return { valid: true };
+        }
+        catch {
+            return {
+                valid: false,
+                error: this.errorMessage
+            };
+        }
+    }
+}
+/**
+ * Date range validator
+ */
+export class DateRangeValidator {
+    constructor(minDate, maxDate, customMessage) {
+        this.minDate = minDate;
+        this.maxDate = maxDate;
+        this.errorMessage = customMessage ?? this.buildErrorMessage();
+    }
+    validate(value) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true };
+        }
+        const date = value instanceof Date ? value : new Date(value);
+        if (isNaN(date.getTime())) {
+            return {
+                valid: false,
+                error: 'Invalid date'
+            };
+        }
+        if (this.minDate && date < this.minDate) {
+            return {
+                valid: false,
+                error: `Date must be on or after ${this.minDate.toLocaleDateString()}`
+            };
+        }
+        if (this.maxDate && date > this.maxDate) {
+            return {
+                valid: false,
+                error: `Date must be on or before ${this.maxDate.toLocaleDateString()}`
+            };
+        }
+        return { valid: true };
+    }
+    buildErrorMessage() {
+        if (this.minDate && this.maxDate) {
+            return `Date must be between ${this.minDate.toLocaleDateString()} and ${this.maxDate.toLocaleDateString()}`;
+        }
+        else if (this.minDate) {
+            return `Date must be on or after ${this.minDate.toLocaleDateString()}`;
+        }
+        else if (this.maxDate) {
+            return `Date must be on or before ${this.maxDate.toLocaleDateString()}`;
+        }
+        return 'Invalid date';
+    }
+}
+/**
+ * Custom function validator
+ */
+export class FunctionValidator {
+    constructor(validateFn, customMessage) {
+        this.validateFn = validateFn;
+        this.errorMessage = 'Validation failed';
+        if (customMessage) {
+            this.errorMessage = customMessage;
+        }
+    }
+    validate(value) {
+        const result = this.validateFn(value);
+        if (typeof result === 'boolean') {
+            return {
+                valid: result,
+                error: result ? undefined : this.errorMessage
+            };
+        }
+        return result;
+    }
+}
+/**
+ * Composite validator - chains multiple validators (Chain of Responsibility)
+ */
+export class ChainValidator {
+    constructor(validators) {
+        this.errorMessage = 'Validation failed';
+        this.validators = [];
+        if (validators) {
+            this.validators = validators;
+        }
+    }
+    addValidator(validator) {
+        this.validators.push(validator);
+        return this;
+    }
+    getValidators() {
+        return [...this.validators];
+    }
+    validate(value) {
+        const errors = {};
+        let allValid = true;
+        for (let i = 0; i < this.validators.length; i++) {
+            const validator = this.validators[i];
+            const result = validator.validate(value);
+            if (!result.valid) {
+                allValid = false;
+                errors[`validator_${i}`] = result.error || 'Validation failed';
+            }
+        }
+        if (!allValid) {
+            const firstError = Object.values(errors)[0];
+            return {
+                valid: false,
+                error: firstError,
+                errors
+            };
+        }
+        return { valid: true };
+    }
+}
+/**
+ * Pattern validators for common use cases
+ */
+export class PatternValidators {
+    static email(message) {
+        return new EmailValidator(message);
+    }
+    static url(message) {
+        return new UrlValidator(message);
+    }
+    static required(message) {
+        return new RequiredValidator(message);
+    }
+    static range(min, max, message) {
+        return new RangeValidator(min, max, message);
+    }
+    static stringLength(min, max, message) {
+        return new LengthValidator(min, max, message);
+    }
+    static regex(pattern, message) {
+        return new RegexValidator(pattern, message);
+    }
+    static dateRange(min, max, message) {
+        return new DateRangeValidator(min, max, message);
+    }
+    static custom(fn, message) {
+        return new FunctionValidator(fn, message);
+    }
+    static chain(...validators) {
+        return new ChainValidator(validators);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-validators.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/strategies/default-validators.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Default validator implementations\n */\n\nimport { CellValidator, CompositeValidator } from '../models/cell-strategies.interface';\nimport { ValidationResult, isNullOrUndefined } from '../models/cell-types';\n\n/**\n * Required validator - ensures value is not empty\n */\nexport class RequiredValidator implements CellValidator<any> {\n  errorMessage = 'This field is required';\n\n  constructor(private readonly customMessage?: string) {\n    if (customMessage) {\n      this.errorMessage = customMessage;\n    }\n  }\n\n  validate(value: any): ValidationResult {\n    const isEmpty = isNullOrUndefined(value) || \n                   (typeof value === 'string' && value.trim() === '') ||\n                   (Array.isArray(value) && value.length === 0);\n\n    return {\n      valid: !isEmpty,\n      error: isEmpty ? this.errorMessage : undefined\n    };\n  }\n}\n\n/**\n * Range validator - validates numeric range\n */\nexport class RangeValidator implements CellValidator<number> {\n  errorMessage: string;\n\n  constructor(\n    private readonly min?: number,\n    private readonly max?: number,\n    customMessage?: string\n  ) {\n    this.errorMessage = customMessage ?? this.buildErrorMessage();\n  }\n\n  validate(value: number): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true }; // Use RequiredValidator for required checks\n    }\n\n    if (typeof value !== 'number' || isNaN(value)) {\n      return {\n        valid: false,\n        error: 'Value must be a number'\n      };\n    }\n\n    if (this.min !== undefined && value < this.min) {\n      return {\n        valid: false,\n        error: `Value must be at least ${this.min}`\n      };\n    }\n\n    if (this.max !== undefined && value > this.max) {\n      return {\n        valid: false,\n        error: `Value must be at most ${this.max}`\n      };\n    }\n\n    return { valid: true };\n  }\n\n  private buildErrorMessage(): string {\n    if (this.min !== undefined && this.max !== undefined) {\n      return `Value must be between ${this.min} and ${this.max}`;\n    } else if (this.min !== undefined) {\n      return `Value must be at least ${this.min}`;\n    } else if (this.max !== undefined) {\n      return `Value must be at most ${this.max}`;\n    }\n    return 'Invalid value';\n  }\n}\n\n/**\n * String length validator\n */\nexport class LengthValidator implements CellValidator<string> {\n  errorMessage: string;\n\n  constructor(\n    private readonly minLength?: number,\n    private readonly maxLength?: number,\n    customMessage?: string\n  ) {\n    this.errorMessage = customMessage ?? this.buildErrorMessage();\n  }\n\n  validate(value: string): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true };\n    }\n\n    const length = String(value).length;\n\n    if (this.minLength !== undefined && length < this.minLength) {\n      return {\n        valid: false,\n        error: `Minimum length is ${this.minLength} characters`\n      };\n    }\n\n    if (this.maxLength !== undefined && length > this.maxLength) {\n      return {\n        valid: false,\n        error: `Maximum length is ${this.maxLength} characters`\n      };\n    }\n\n    return { valid: true };\n  }\n\n  private buildErrorMessage(): string {\n    if (this.minLength !== undefined && this.maxLength !== undefined) {\n      return `Length must be between ${this.minLength} and ${this.maxLength} characters`;\n    } else if (this.minLength !== undefined) {\n      return `Minimum length is ${this.minLength} characters`;\n    } else if (this.maxLength !== undefined) {\n      return `Maximum length is ${this.maxLength} characters`;\n    }\n    return 'Invalid length';\n  }\n}\n\n/**\n * Regex validator - validates against regular expression\n */\nexport class RegexValidator implements CellValidator<string> {\n  errorMessage = 'Invalid format';\n\n  constructor(\n    private readonly pattern: RegExp | string,\n    customMessage?: string\n  ) {\n    if (customMessage) {\n      this.errorMessage = customMessage;\n    }\n  }\n\n  validate(value: string): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true };\n    }\n\n    const regex = typeof this.pattern === 'string' \n      ? new RegExp(this.pattern) \n      : this.pattern;\n\n    const isValid = regex.test(String(value));\n\n    return {\n      valid: isValid,\n      error: isValid ? undefined : this.errorMessage\n    };\n  }\n}\n\n/**\n * Email validator\n */\nexport class EmailValidator implements CellValidator<string> {\n  errorMessage = 'Invalid email address';\n\n  private readonly emailPattern = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n\n  constructor(customMessage?: string) {\n    if (customMessage) {\n      this.errorMessage = customMessage;\n    }\n  }\n\n  validate(value: string): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true };\n    }\n\n    const isValid = this.emailPattern.test(String(value));\n\n    return {\n      valid: isValid,\n      error: isValid ? undefined : this.errorMessage\n    };\n  }\n}\n\n/**\n * URL validator\n */\nexport class UrlValidator implements CellValidator<string> {\n  errorMessage = 'Invalid URL';\n\n  constructor(customMessage?: string) {\n    if (customMessage) {\n      this.errorMessage = customMessage;\n    }\n  }\n\n  validate(value: string): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true };\n    }\n\n    try {\n      new URL(String(value));\n      return { valid: true };\n    } catch {\n      return {\n        valid: false,\n        error: this.errorMessage\n      };\n    }\n  }\n}\n\n/**\n * Date range validator\n */\nexport class DateRangeValidator implements CellValidator<Date> {\n  errorMessage: string;\n\n  constructor(\n    private readonly minDate?: Date,\n    private readonly maxDate?: Date,\n    customMessage?: string\n  ) {\n    this.errorMessage = customMessage ?? this.buildErrorMessage();\n  }\n\n  validate(value: Date): ValidationResult {\n    if (isNullOrUndefined(value)) {\n      return { valid: true };\n    }\n\n    const date = value instanceof Date ? value : new Date(value);\n\n    if (isNaN(date.getTime())) {\n      return {\n        valid: false,\n        error: 'Invalid date'\n      };\n    }\n\n    if (this.minDate && date < this.minDate) {\n      return {\n        valid: false,\n        error: `Date must be on or after ${this.minDate.toLocaleDateString()}`\n      };\n    }\n\n    if (this.maxDate && date > this.maxDate) {\n      return {\n        valid: false,\n        error: `Date must be on or before ${this.maxDate.toLocaleDateString()}`\n      };\n    }\n\n    return { valid: true };\n  }\n\n  private buildErrorMessage(): string {\n    if (this.minDate && this.maxDate) {\n      return `Date must be between ${this.minDate.toLocaleDateString()} and ${this.maxDate.toLocaleDateString()}`;\n    } else if (this.minDate) {\n      return `Date must be on or after ${this.minDate.toLocaleDateString()}`;\n    } else if (this.maxDate) {\n      return `Date must be on or before ${this.maxDate.toLocaleDateString()}`;\n    }\n    return 'Invalid date';\n  }\n}\n\n/**\n * Custom function validator\n */\nexport class FunctionValidator<T = any> implements CellValidator<T> {\n  errorMessage = 'Validation failed';\n\n  constructor(\n    private readonly validateFn: (value: T) => boolean | ValidationResult,\n    customMessage?: string\n  ) {\n    if (customMessage) {\n      this.errorMessage = customMessage;\n    }\n  }\n\n  validate(value: T): ValidationResult {\n    const result = this.validateFn(value);\n\n    if (typeof result === 'boolean') {\n      return {\n        valid: result,\n        error: result ? undefined : this.errorMessage\n      };\n    }\n\n    return result;\n  }\n}\n\n/**\n * Composite validator - chains multiple validators (Chain of Responsibility)\n */\nexport class ChainValidator<T = any> implements CompositeValidator<T> {\n  errorMessage = 'Validation failed';\n\n  private validators: CellValidator<T>[] = [];\n\n  constructor(validators?: CellValidator<T>[]) {\n    if (validators) {\n      this.validators = validators;\n    }\n  }\n\n  addValidator(validator: CellValidator<T>): this {\n    this.validators.push(validator);\n    return this;\n  }\n\n  getValidators(): CellValidator<T>[] {\n    return [...this.validators];\n  }\n\n  validate(value: T): ValidationResult {\n    const errors: Record<string, string> = {};\n    let allValid = true;\n\n    for (let i = 0; i < this.validators.length; i++) {\n      const validator = this.validators[i];\n      const result = validator.validate(value);\n\n      if (!result.valid) {\n        allValid = false;\n        errors[`validator_${i}`] = result.error || 'Validation failed';\n      }\n    }\n\n    if (!allValid) {\n      const firstError = Object.values(errors)[0];\n      return {\n        valid: false,\n        error: firstError,\n        errors\n      };\n    }\n\n    return { valid: true };\n  }\n}\n\n/**\n * Async validator interface (for future implementation)\n */\nexport interface AsyncCellValidator<T = any> {\n  validateAsync(value: T): Promise<ValidationResult>;\n}\n\n/**\n * Pattern validators for common use cases\n */\nexport class PatternValidators {\n  static email(message?: string): EmailValidator {\n    return new EmailValidator(message);\n  }\n\n  static url(message?: string): UrlValidator {\n    return new UrlValidator(message);\n  }\n\n  static required(message?: string): RequiredValidator {\n    return new RequiredValidator(message);\n  }\n\n  static range(min?: number, max?: number, message?: string): RangeValidator {\n    return new RangeValidator(min, max, message);\n  }\n\n  static stringLength(min?: number, max?: number, message?: string): LengthValidator {\n    return new LengthValidator(min, max, message);\n  }\n\n  static regex(pattern: RegExp | string, message?: string): RegexValidator {\n    return new RegexValidator(pattern, message);\n  }\n\n  static dateRange(min?: Date, max?: Date, message?: string): DateRangeValidator {\n    return new DateRangeValidator(min, max, message);\n  }\n\n  static custom<T>(fn: (value: T) => boolean | ValidationResult, message?: string): FunctionValidator<T> {\n    return new FunctionValidator(fn, message);\n  }\n\n  static chain<T>(...validators: CellValidator<T>[]): ChainValidator<T> {\n    return new ChainValidator(validators);\n  }\n}\n\n"]}