ngx-lift 1.4.2 → 1.6.0

package/fesm2022/ngx-lift.mjs

@@ -2,8 +2,8 @@ import { startWith, Subject, combineLatest, pipe, tap, map, catchError, of, Obse
 import { toObservable, toSignal } from '@angular/core/rxjs-interop';
 import * as i0 from '@angular/core';
 import { Pipe, inject, LOCALE_ID, assertInInjectionContext, isSignal, untracked, computed, DestroyRef, signal, effect } from '@angular/core';
-import { ActivatedRoute } from '@angular/router';
 import { Validators, FormArray } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
 
 /**
  * Combines multiple observables into a single observable emitting an array or dictionary
@@ -207,18 +207,6 @@ function isPromise$1(obj) {
     return !!obj && typeof obj.then === 'function';
 }
 
-/**
- * Polls data at a specified interval and can be triggered manually.
- *
- * @template Data - The type of the data emitted by the polling function.
- * @template Input - The type of the input parameter used to build polling parameters.
- * @param {object} options - The configuration options for polling.
- * @param {number} options.interval - The interval in milliseconds between each poll.
- * @param {(params: any) => Observable<Data> | Data} options.pollingFn - A function that returns an Observable, Promise, or primitive value.
- * @param {(input: Input | undefined) => any} [options.paramsBuilder] - An optional function that builds parameters for the polling function based on the input. The value emitted by the trigger observable will serve as the parameter.
- * @param {Observable<Input> | Signal<Input>} [options.trigger] - An optional Observable or Signal that triggers a manual poll.
- * @returns {Observable<AsyncState<Data>>} An Observable emitting objects representing the state of the asynchronous operation.
- */
 function poll(options) {
     const timerEmitValue = '__timer__emission__';
     const timer$ = timer(0, options.interval).pipe(map((i) => `${timerEmitValue}${i}`));
@@ -466,14 +454,204 @@ const translations = {
     },
 };
 
+/**
+ * Calculates the difference in whole days between two dates.
+ *
+ * @param {Date | number | string} dateLeft - The date from which the difference is measured (the reference date).
+ *   Can be a Date object, a number representing milliseconds since the Unix epoch,
+ *   or a string in a format parseable by the Date constructor.
+ * @param {Date | number | string} dateRight - The date to be compared against the reference date.
+ *   Can be a Date object, a number representing milliseconds since the Unix epoch,
+ *   or a string in a format parseable by the Date constructor.
+ * @returns {number} The number of whole days between the reference date (dateLeft) and the compared date (dateRight).
+ *
+ * @example
+ * // How many whole days are between '2022-09-08' and '2023-09-18'?
+ * const result = differenceInDays('2022-09-08', new Date('2023-09-18'));
+ */
+function differenceInDays(dateLeft, dateRight) {
+    const _dateLeft = new Date(dateLeft);
+    const _dateRight = new Date(dateRight);
+    const difference = (_dateLeft.getTime() - _dateRight.getTime()) / (1000 * 60 * 60 * 24);
+    return Math.floor(difference);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Create an object composed of object properties that do not satisfy a given condition.
+ * @param {T} source - The object to omit properties from.
+ * @param {(value: T[keyof T], key: string) => boolean} predicate - The function invoked per property.
+ * @returns {Partial<T>} - Returns the new object.
+ */
+function omitBy(source, predicate) {
+    // Negate the predicate and pass it to pickBy
+    return pickBy(source, (value, key) => !predicate(value, key));
+}
+
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+ * A step of -1 is used if a negative start is specified without an end or step.
+ * If end is not specified, it's set to start with start then set to 0.
+ *
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} step The value to increment or decrement by.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Array} Returns the range of numbers.
+ */
+function range(start, end, step, fromRight = false) {
+    // if range takes only 1 input, that input is end, start with 0
+    if (end === undefined) {
+        end = start;
+        start = 0;
+    }
+    step = step === undefined ? (start < end ? 1 : -1) : step;
+    let index = -1;
+    let length = Math.max(Math.ceil((end - start) / (step || 1)), 0);
+    const result = new Array(length);
+    while (length--) {
+        result[fromRight ? length : ++index] = start;
+        start += step;
+    }
+    return result;
+}
+
 // 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()@:%_+.~#?&/=]*)$/;
+// https://regex101.com/library/dT0vT3?orderBy=RELEVANCE&search=ip
+const ipRegex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+// A fully qualified domain name (FQDN) is a domain name that specifies its exact location in the tree hierarchy of the Domain Name System (DNS)
+// https://www.regextester.com/103452
+const fqdnRegex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{0,62}[a-zA-Z0-9]\.)+[a-zA-Z]{2,63}$)/;
+
+function isIP(ip) {
+    return ipRegex.test(ip);
+}
+function isFQDN(fqdn) {
+    return fqdnRegex.test(fqdn);
+}
+function isURL(url) {
+    return urlPattern.test(url);
+}
+function isHttps(url) {
+    return httpsPattern.test(url);
+}
 
 class IsHttpsPipe {
     transform(value) {
-        return httpsPattern.test(value);
+        return isHttps(value);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.2", ngImport: i0, type: IsHttpsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
     static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.2", ngImport: i0, type: IsHttpsPipe, isStandalone: true, name: "isHttps" }); }
@@ -520,6 +698,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.2", ngImpor
                 }]
         }] });
 
+class RangePipe {
+    transform(value) {
+        const input = value;
+        return range(...input);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.2", ngImport: i0, type: RangePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.2", ngImport: i0, type: RangePipe, isStandalone: true, name: "range" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.2", ngImport: i0, type: RangePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'range',
+                    standalone: true,
+                }]
+        }] });
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Combines multiple `Observable` or `Signal` sources into a `Signal` that emits their values. It's like combineLatest.
@@ -818,136 +1012,38 @@ function parseArgs(args) {
 }
 
 /**
- * Calculates the difference in whole days between two dates.
- *
- * @param {Date | number | string} dateLeft - The date from which the difference is measured (the reference date).
- *   Can be a Date object, a number representing milliseconds since the Unix epoch,
- *   or a string in a format parseable by the Date constructor.
- * @param {Date | number | string} dateRight - The date to be compared against the reference date.
- *   Can be a Date object, a number representing milliseconds since the Unix epoch,
- *   or a string in a format parseable by the Date constructor.
- * @returns {number} The number of whole days between the reference date (dateLeft) and the compared date (dateRight).
- *
- * @example
- * // How many whole days are between '2022-09-08' and '2023-09-18'?
- * const result = differenceInDays('2022-09-08', new Date('2023-09-18'));
- */
-function differenceInDays(dateLeft, dateRight) {
-    const _dateLeft = new Date(dateLeft);
-    const _dateRight = new Date(dateRight);
-    const difference = (_dateLeft.getTime() - _dateRight.getTime()) / (1000 * 60 * 60 * 24);
-    return Math.floor(difference);
-}
-
-/**
- * Provides a conditional validator that applies the specified validator functions only if the condition is met.
+ * A custom validator function that checks for intersection between two form controls. The two controls' values must be arrays.
  *
- * @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.
+ * @param {string} controlName1 - The name of the first form control.
+ * @param {string} controlName2 - The name of the second form control.
+ * @returns {ValidatorFn} A function that validates the form group and returns an error if there is an intersection.
  */
-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);
+function intersectionValidator(controlName1, controlName2) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (formGroup) => {
+        const control1 = formGroup.get(controlName1);
+        const control2 = formGroup.get(controlName2);
+        if (!control1 || !control2) {
+            return null; // If either control is undefined or null
         }
-        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);
+        const value1 = control1.value;
+        const value2 = control2.value;
+        // Assuming both values are arrays
+        if (!Array.isArray(value1) || !Array.isArray(value2)) {
+            return 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;
+        const intersection = value1.filter((value) => value2.includes(value));
+        if (intersection.length > 0) {
+            control1.setErrors({ intersection: true });
+            control2.setErrors({ intersection: true });
+            return { intersection: true };
         }
-    }
-    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];
+        else {
+            control1.setErrors(null);
+            control2.setErrors(null);
+            return null;
         }
-    }
-    return result;
+    };
 }
 
 /**
@@ -1034,5 +1130,5 @@ function httpsValidator(control) {
  * Generated bundle index. Do not edit.
  */
 
-export { ArrayJoinPipe, ByteConverterPipe, IsHttpsPipe, MaskPipe, UniqueValidator, combineFrom, combineLatestEager, computedAsync, createAsyncState, createTrigger, differenceInDays, distinctOnChange, httpsValidator, ifAsyncValidator, ifValidator, injectParams, injectQueryParams, isEmpty, isEqual, logger, mergeFrom, pickBy, poll, startWithTap, switchMapWithAsyncState, urlValidator };
+export { ArrayJoinPipe, ByteConverterPipe, IsHttpsPipe, MaskPipe, RangePipe, UniqueValidator, combineFrom, combineLatestEager, computedAsync, createAsyncState, createTrigger, differenceInDays, distinctOnChange, httpsValidator, ifAsyncValidator, ifValidator, injectParams, injectQueryParams, intersectionValidator, isEmpty, isEqual, isFQDN, isHttps, isIP, isURL, logger, mergeFrom, omitBy, pickBy, poll, range, startWithTap, switchMapWithAsyncState, urlValidator };
 //# sourceMappingURL=ngx-lift.mjs.map