ngx-lift 0.4.0

package/fesm2022/ngx-lift.mjs

@@ -0,0 +1,707 @@
+import { startWith, Subject, combineLatest, tap, map, of, catchError, pipe, Observable, exhaustMap, share, EMPTY, timer, merge, switchMap } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Pipe, LOCALE_ID, Inject } from '@angular/core';
+import { Validators, FormArray } from '@angular/forms';
+
+/**
+ * Combines multiple observables into a single observable emitting an array or dictionary
+ * of the latest values from each source observable.
+ * Adds startWith(null) for each Subject in combineLatest when the second parameter startWithNullForAll is false.
+ * When startWithNullForAll is true, each observable will startWith null.
+ *
+ * @template T - The type of the data in the observables.
+ *
+ * @param {Array<Observable<T>> | Record<string, Observable<T>>} sources -
+ *   An array of observables or a dictionary of observables to be combined.
+ *
+ * @param {boolean} [startWithNullForAll=false] -
+ *   Determines whether to start each observable with a `null` value.
+ *
+ * @returns {Observable<Array<T | null> | Record<string, T | null>>} -
+ *   An observable emitting an array or dictionary of the latest values from each source observable.
+ *
+ * @throws {Error} -
+ *   Throws an error if the provided argument is not an array of observables or a dictionary of observables.
+ */
+function combineLatestEager(sources, startWithNullForAll = false) {
+    function observableMapper(observable) {
+        if (startWithNullForAll) {
+            return observable.pipe(startWith(null));
+        }
+        else {
+            // Check if observable is a Subject, if true, apply startWith(null)
+            return observable instanceof Subject ? observable.pipe(startWith(null)) : observable;
+        }
+    }
+    if (Array.isArray(sources)) {
+        // If sources is an array of observables
+        return combineLatest(sources.map(observableMapper));
+    }
+    else if (typeof sources === 'object' && sources !== null) {
+        // If sources is a dictionary of observables
+        const observables = {};
+        for (const [key, value] of Object.entries(sources)) {
+            observables[key] = observableMapper(value);
+        }
+        return combineLatest(observables);
+    }
+    else {
+        throw new Error(`Invalid argument type. Please provide an array of observables or a dictionary of observables. Received: ${typeof sources}`);
+    }
+}
+
+/**
+ * createAsyncState transforms an Observable of type T into an Observable of AsyncState<T>.
+ * AsyncState<T> represents the loading, error, and data states for asynchronous operations.
+ *
+ * @template T - The type of the data in the observable.
+ * @template E - The type of the error that can occur.
+ *
+ * @param {Partial<Observer<T>> | ((value: T) => void)} [observerOrNextForOrigin] -
+ *   An optional parameter that can be a partial TapObserver<T> or a function to handle the next value or error in the original Observable.
+ *
+ * @returns {UnaryFunction<Observable<T>, Observable<AsyncState<T, E>>>} -
+ *   A function that transforms an observable stream into an asynchronous state.
+ *
+ * @example
+ * Usage 1: Simple request
+ * data$ = this.shopService.products$.pipe(
+ *   createAsyncState({
+ *    next: res => console.log('Side effect if success: ' + res),
+ *    error: error => console.error('Side effect if error: ' + error.message)
+ *   })
+ * );
+ *
+ * Usage 2: Dependent requests
+ * data$ = firstCall$.pipe(
+ *   switchMap(() => this.shopService.products$),
+ *   createAsyncState()
+ * );
+ *
+ * Another implementation thought when refreshing the data: instead of startWith, `merge of` emit as the trigger
+ *
+ * subject.pipe(
+ *   switchMap(() => merge(
+ *     of({ loading: true, error: null, data: null }),
+ *     this.service.apiCall().pipe(
+ *       map(data => ({ loading: false, error: null, data })),
+ *       tap({
+ *         next: res => callback?.(res.data),
+ *         error: err => errorCallback?.(err),
+ *       }),
+ *       catchError(error => of({ loading: false, error, data: null })),
+ *     ),
+ *   ))
+ * )
+ *
+ */
+function createAsyncState(observerOrNextForOrigin) {
+    return pipe(tap(observerOrNextForOrigin), map((data) => ({ loading: false, error: null, data })), startWith({ loading: true, error: null, data: null }), 
+    // retry(1), // if you want to add retry
+    catchError((error) => of({ loading: false, error, data: null })));
+}
+
+/**
+ * Creates an operator function for RxJS Observables that filters out consecutive
+ * values that are considered equal according to a provided comparator function,
+ * and invokes a callback when a distinct value is encountered.
+ *
+ * @template T - The type of elements emitted by the observable.
+ * @param {(previousValue: T, currentValue: T) => void} onChangeCallback
+ *   A callback function that will be invoked when a distinct value is encountered.
+ *   It receives the previous distinct value and the current value.
+ * @param {(previousValue: T, currentValue: T) => boolean} [comparator]
+ *   A function that determines if two values are considered equal.
+ *   Defaults to a function that performs strict equality (===) comparison.
+ * @returns {OperatorFunction<T, T>} - The RxJS operator function.
+ *
+ * @example
+ * Example 1:
+ * const source$ = new Observable<number>((observer) => {
+ *   observer.next(1);
+ *   observer.next(2);
+ *   observer.next(2);
+ *   observer.next(3);
+ *   observer.next(3);
+ *   observer.next(4);
+ *   observer.next(5);
+ *   observer.complete();
+ * });
+ *
+ * const distinctOnChange$ = source$.pipe(
+ *   distinctOnChange(
+ *     (prev, curr) => console.log(`Value changed from ${prev} to: ${curr}`),
+ *     (prev, curr) => prev === curr,
+ *   ),
+ * );
+ * distinctOnChange$.subscribe((res) => console.log(res));
+ *
+ *
+ * Example 2:
+ * distinctOnChange<RDEValue<OseInstance>[]>(
+ *   () => {
+ *     this.store.dispatch(
+ *       addToast({
+ *         toast: {
+ *           type: ToastType.SUCCESS,
+ *           title: this.l10nService.getMessage('STATUS_CHANGE'),
+ *           description: this.l10nService.getMessage('STATUS_CHANGE_DESC'),
+ *         },
+ *       }),
+ *     );
+ *   },
+ *   (prev, current) =>
+ *     prev.every((prevInstance, index) => instanceComparator(prevInstance.entity, current[index].entity)),
+ * );
+ */
+function distinctOnChange(onChangeCallback, comparator = (prev, curr) => prev === curr) {
+    return (source) => new Observable((subscriber) => {
+        let hasFirstValue = false;
+        let previousValue;
+        const subscription = source.subscribe({
+            next: (currentValue) => {
+                if (hasFirstValue) {
+                    if (!comparator(previousValue, currentValue)) {
+                        onChangeCallback(previousValue, currentValue);
+                        previousValue = currentValue;
+                        subscriber.next(currentValue);
+                    }
+                }
+                else {
+                    previousValue = currentValue;
+                    hasFirstValue = true;
+                    subscriber.next(currentValue);
+                }
+            },
+            error: (err) => subscriber.error(err),
+            complete: () => subscriber.complete(),
+        });
+        return () => subscription.unsubscribe();
+    });
+}
+
+// Map each LoggerType to its corresponding console function
+const loggerFunctions = {
+    count: console.count.bind(console),
+    debug: console.debug.bind(console),
+    dir: console.dir.bind(console),
+    log: console.log.bind(console),
+    table: console.table.bind(console),
+};
+/**
+ * Logger operator for RxJS observables.
+ *
+ * @param loggerType The type of logger to be used: 'count', 'debug', 'dir', 'log', 'table'.
+ *                   Defaults to 'log' if not provided or if an unknown type is specified.
+ * @returns An RxJS operator function that logs values using the specified console function.
+ */
+const logger = (loggerType = 'log') => pipe(tap((value) => {
+    const logFunction = loggerFunctions[loggerType] || console.log.bind(console);
+    logFunction(value);
+}));
+
+/**
+ * Polls the API at a specified interval, handling the triggering of requests and building parameters.
+ *
+ * @param {Object} options - The options object containing interval, apiCall, paramsBuilder, and trigger
+ * @param {number} options.interval - The interval at which to poll the API
+ * @param {(params: Record<string, unknown>) => Observable<Data>} options.apiCall - The function to call the API
+ * @param {(input: Input | null) => Record<string, unknown>} [options.paramsBuilder] - The function to build parameters based on input
+ * @param {Observable<Input>} [options.trigger] - The trigger observable for initiating requests
+ * @return {Observable<AsyncState<Data>>} An observable emitting the async state of the API data
+ */
+function poll(options) {
+    let latestInput = null;
+    return merge(options.trigger || EMPTY, timer(0, options.interval)).pipe(exhaustMap((input) => {
+        let params = {};
+        const triggeredByObservable = typeof input !== 'number';
+        if (triggeredByObservable) {
+            latestInput = input;
+        }
+        if (options.paramsBuilder) {
+            params = options.paramsBuilder(latestInput);
+        }
+        const isFirstRequest = input === 0;
+        const shouldShowLoading = triggeredByObservable || isFirstRequest;
+        let observable = options.apiCall(params).pipe(map((data) => ({ loading: false, error: null, data })), catchError((error) => of({ loading: false, error, data: null })));
+        if (shouldShowLoading) {
+            observable = observable.pipe(startWith({ loading: true, error: null, data: null }));
+        }
+        return observable;
+    }), share());
+}
+
+/**
+ * Operator that taps into a callback before the source Observable starts emitting values.
+ *
+ * This operator is useful for triggering a side effect before the main Observable starts emitting.
+ *
+ * @param callback A function to be executed before the source Observable emits its first value.
+ * @returns An RxJS operator function that taps into the callback and then switchMaps to the source Observable.
+ */
+function startWithTap(callback) {
+    return (source) => {
+        callback();
+        return source;
+    };
+}
+
+/**
+ * Custom RxJS operator that uses switchMap to handle asynchronous operations and
+ * transforms the emitted values into an AsyncState object.
+ *
+ * @template T - The type of data emitted by the observable returned by the project.
+ * @template K - The type of value emitted by the source observable.
+ * @template E - The type of error that can be encountered during the asynchronous operation.
+ *
+ * @param {function(K): Observable<T>} project - A function that takes a value emitted by the source
+ * observable and returns an observable representing an asynchronous operation.
+ *
+ * @returns {OperatorFunction<K, AsyncState<T, E>>} - An RxJS operator that transforms the source observable into
+ * an observable of AsyncState objects.
+ *
+ * @example
+ * // Usage of the switchMapWithAsyncState operator
+ * const source$ = new BehaviorSubject<number>(1);
+ *
+ * const asyncOperation = (value: number) => {
+ *   return of(value * 2).pipe(delay(1000));
+ * };
+ *
+ * const result$ = source$.pipe(switchMapWithAsyncState(asyncOperation));
+ * result$.subscribe((state) => {
+ *   console.log(state); // Outputs AsyncState objects with loading, data, and error properties.
+ * });
+ */
+function switchMapWithAsyncState(project) {
+    return (source) => source.pipe(switchMap((value, index) => project(value, index).pipe(createAsyncState())));
+}
+
+class ArrayJoinPipe {
+    transform(value, separator = ',') {
+        if (Array.isArray(value)) {
+            return value.join(separator);
+        }
+        // For non-array cases or unexpected types, return the value as is
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ArrayJoinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: ArrayJoinPipe, isStandalone: true, name: "arrayJoin" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ArrayJoinPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayJoin',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * import { LOCALE_ID, NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { AppComponent } from './app.component';
+ * import { registerLocaleData } from '@angular/common';
+ *
+ * import localeEn from '@angular/common/locales/en';
+ * import localeFr from '@angular/common/locales/fr';
+ *
+ * // Register locales
+ * registerLocaleData(localeEn);
+ * registerLocaleData(localeFr);
+ *
+ * @NgModule({
+ *   declarations: [AppComponent],
+ *   imports: [BrowserModule],
+ *   providers: [
+ *     {
+ *       provide: LOCALE_ID,
+ *       useFactory: () => {
+ *         // Use the browser's language or a default language
+ *         return navigator.language || 'en';
+ *       },
+ *     },
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ */
+class ByteConverterPipe {
+    constructor(locale) {
+        this.locale = locale;
+    }
+    // If using navigator.language directly in the pipe, this approach directly uses the browser's language at the moment the ByteConverterPipe is constructed. If the user changes the language while using the application, it won't be automatically reflected. If dynamic language changes are a requirement, using the LOCALE_ID provider as demonstrated in the AppModule is a more Angular-centric approach.
+    // private locale: string;
+    // constructor() {
+    //   // Use navigator.language as the default locale
+    //   this.locale = navigator.language || 'en';
+    // }
+    transform(value) {
+        if (value === null || value === undefined || isNaN(value)) {
+            return '-';
+        }
+        const units = ['BYTE', 'KB', 'MB', 'GB', 'TB'];
+        let unitIndex = 0;
+        while (value >= 1024 && unitIndex < units.length - 1) {
+            value /= 1024;
+            unitIndex++;
+        }
+        const translationObject = translations[this.locale] || translations['en'];
+        const key = units[unitIndex];
+        return this.formatNumber(value) + ' ' + translationObject[key];
+    }
+    formatNumber(value) {
+        return new Intl.NumberFormat(this.locale, { maximumFractionDigits: 2 }).format(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ByteConverterPipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: ByteConverterPipe, isStandalone: true, name: "byteConverter" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ByteConverterPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'byteConverter',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }] });
+const translations = {
+    en: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    'en-US': {
+        // You can provide specific variations for en-US if needed
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    de: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    es: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    fr: {
+        BYTE: 'o',
+        KB: 'Ko',
+        MB: 'Mo',
+        GB: 'Go',
+        TB: 'To',
+    },
+    it: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    ja: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    ko: {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    'pt-BR': {
+        BYTE: 'B',
+        KB: 'KB',
+        MB: 'MB',
+        GB: 'GB',
+        TB: 'TB',
+    },
+    'zh-CN': {
+        BYTE: '字节',
+        KB: '千字节',
+        MB: '兆字节',
+        GB: '千兆字节',
+        TB: '太字节',
+    },
+    'zh-TW': {
+        BYTE: '位元組',
+        KB: '千位元組',
+        MB: '兆位元組',
+        GB: '千兆位元組',
+        TB: '太位元組',
+    },
+    ru: {
+        BYTE: 'Б',
+        KB: 'КБ',
+        MB: 'МБ',
+        GB: 'ГБ',
+        TB: 'ТБ',
+    },
+};
+
+// https://regex101.com/library/mX1xW0
+const emailPattern = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/;
+const urlPattern = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+const httpsPattern = /^https:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+
+class IsHttpsPipe {
+    transform(value) {
+        return httpsPattern.test(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: IsHttpsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: IsHttpsPipe, isStandalone: true, name: "isHttps" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: IsHttpsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isHttps',
+                    standalone: true,
+                }]
+        }] });
+
+const unmaskNumber = 6;
+const maskChar = '*';
+class MaskPipe {
+    /**
+     * Transforms the input string by masking characters based on the provided options.
+     *
+     * @param {string} value - The input string to be masked.
+     * @param {MaskOptions} [options={}] - Options for customizing the masking behavior.
+     * @returns {string} - The masked string.
+     */
+    transform(value, options = {}) {
+        const { unmaskedPrefixLength = unmaskNumber, unmaskedSuffixLength = unmaskNumber, masked = true } = options;
+        if (value.length <= unmaskedPrefixLength + unmaskedSuffixLength ||
+            unmaskedPrefixLength < 0 ||
+            unmaskedSuffixLength < 0 ||
+            !masked) {
+            return value;
+        }
+        return value
+            .split('')
+            .map((char, i) => (i < unmaskedPrefixLength || i > value.length - unmaskedSuffixLength - 1 ? char : maskChar))
+            .join('');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: MaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: MaskPipe, isStandalone: true, name: "mask" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: MaskPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mask',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Provides a conditional validator that applies the specified validator functions only if the condition is met.
+ *
+ * @param condition A function that determines whether the validators should be applied.
+ * @param trueValidatorFn The validator function or an array of validator functions to be applied when the condition is true.
+ * @param falseValidatorFn Optional. The validator function or an array of validator functions to be applied when the condition is false.
+ * @returns A validator function that can be used with Angular Reactive Forms.
+ */
+function ifValidator(condition, trueValidatorFn, falseValidatorFn) {
+    /**
+     * @param control The AbstractControl to validate.
+     * @returns Validation errors if the condition is met; otherwise, null.
+     */
+    return (control) => {
+        if (!trueValidatorFn || !condition(control)) {
+            return composeValidators(control, falseValidatorFn);
+        }
+        return composeValidators(control, trueValidatorFn);
+    };
+}
+/**
+ * Provides a conditional async validator that applies the specified async validator function only if the condition is met.
+ *
+ * @param condition A function that determines whether the async validator should be applied.
+ * @param validatorFn The async validator function to be applied conditionally.
+ * @returns An async validator function that can be used with Angular Reactive Forms.
+ */
+function ifAsyncValidator(condition, validatorFn) {
+    /**
+     * @param control The AbstractControl to validate asynchronously.
+     * @returns An observable that emits validation errors if the condition is met; otherwise, emits null.
+     */
+    return (control) => {
+        if (!validatorFn || !condition(control)) {
+            return of(null);
+        }
+        return validatorFn(control);
+    };
+}
+/**
+ * Composes and applies the provided validators to the given AbstractControl.
+ *
+ * @param control The AbstractControl to validate.
+ * @param validatorFn The validator function or an array of validator functions to be applied.
+ * @returns Validation errors if the validators are applicable; otherwise, null.
+ */
+function composeValidators(control, validatorFn) {
+    if (!validatorFn) {
+        return null;
+    }
+    const validatorFns = Array.isArray(validatorFn) ? validatorFn : [validatorFn];
+    return Validators.compose(validatorFns)?.(control) || null;
+}
+
+/**
+ * Check if a value is empty.
+ * @param {T | undefined | null} value - The value to check for emptiness.
+ * @returns {boolean} - Returns true if the value is empty, otherwise false.
+ */
+function isEmpty(value) {
+    if (value == null)
+        return true;
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+
+/**
+ * Check if two values are deeply equal.
+ * @param {T} value1 - The first value to compare.
+ * @param {T} value2 - The second value to compare.
+ * @returns {boolean} - Returns true if the values are deeply equal, otherwise false.
+ */
+function isEqual(value1, value2) {
+    if (value1 === value2)
+        return true;
+    if (typeof value1 !== 'object' || typeof value2 !== 'object' || value1 === null || value2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(value1);
+    const keys2 = Object.keys(value2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !isEqual(value1[key], value2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Create an object composed of object properties that satisfy a given condition.
+ * @param {T} source - The object to pick properties from.
+ * @param {(value: T[keyof T], key: string) => boolean} predicate - The function invoked per property.
+ * @returns {Partial<T>} - Returns the new object.
+ */
+function pickBy(source, predicate) {
+    const result = {};
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key) && predicate(source[key], key)) {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}
+
+/**
+ * Validator for checking uniqueness across multiple fields in a FormArray or FormGroup.
+ *
+ * This validator can be applied to a FormArray or FormGroup containing the controls to be validated.
+ * It ensures that each control's value is unique among all other controls within the array or group.
+ */
+class UniqueValidator {
+    /**
+     * Validator function to be attached to a FormArray or FormGroup.
+     *
+     * This validator checks for uniqueness of each control's value within the array or group.
+     *
+     * @param keySelector A function to select the key control for comparison (default is the control itself).
+     * @typeparam T The type of the control value.
+     */
+    static unique(keySelector = (control) => control) {
+        return (formArray) => {
+            if (!(formArray instanceof FormArray)) {
+                return null;
+            }
+            const targetControls = formArray.controls.map(keySelector);
+            const valueControlMap = new Map();
+            const invalidControls = [];
+            for (const control of targetControls) {
+                const value = control.value;
+                if (value == null || String(value) === '' || String(value) === 'NaN') {
+                    continue;
+                }
+                const controlInMap = valueControlMap.get(value);
+                if (controlInMap) {
+                    if (!invalidControls.includes(controlInMap)) {
+                        invalidControls.push(controlInMap);
+                    }
+                    invalidControls.push(control);
+                }
+                else {
+                    valueControlMap.set(value, control);
+                }
+            }
+            const notUniqueError = { notUnique: true };
+            // set errors manually for target controls
+            for (const control of targetControls) {
+                const errors = control.errors;
+                if (invalidControls.includes(control)) {
+                    // set not unique error for invalid controls
+                    control.setErrors(errors === null ? notUniqueError : { ...errors, ...notUniqueError });
+                }
+                else {
+                    // remove not unique errors for valid controls
+                    if (errors === null) {
+                        control.setErrors(null);
+                    }
+                    else {
+                        delete errors['notUnique'];
+                        control.setErrors(Object.keys(errors).length > 0 ? errors : null);
+                    }
+                }
+            }
+            return invalidControls.length > 0 ? notUniqueError : null;
+        };
+    }
+}
+
+function urlValidator(control) {
+    if (!urlPattern.test(control.value)) {
+        return { invalidUrl: true };
+    }
+    return null;
+}
+function httpsValidator(control) {
+    if (!httpsPattern.test(control.value)) {
+        return { invalidUrl: true };
+    }
+    return null;
+}
+
+/*
+ * Public API Surface of ngx-lift
+ */
+// export * from './lib/signals';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ArrayJoinPipe, ByteConverterPipe, IsHttpsPipe, MaskPipe, UniqueValidator, combineLatestEager, createAsyncState, distinctOnChange, httpsValidator, ifAsyncValidator, ifValidator, isEmpty, isEqual, logger, pickBy, poll, startWithTap, switchMapWithAsyncState, urlValidator };
+//# sourceMappingURL=ngx-lift.mjs.map