ngx-lift 0.4.0

package/esm2022/lib/pipes/byte-converter.pipe.mjs

@@ -0,0 +1,159 @@
+import { Inject, LOCALE_ID, Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * 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 {}
+ */
+export 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: 'ТБ',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"byte-converter.pipe.js","sourceRoot":"","sources":["../../../../../projects/ngx-lift/src/lib/pipes/byte-converter.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';\n\n/**\n * import { LOCALE_ID, NgModule } from '@angular/core';\n * import { BrowserModule } from '@angular/platform-browser';\n * import { AppComponent } from './app.component';\n * import { registerLocaleData } from '@angular/common';\n *\n * import localeEn from '@angular/common/locales/en';\n * import localeFr from '@angular/common/locales/fr';\n *\n * // Register locales\n * registerLocaleData(localeEn);\n * registerLocaleData(localeFr);\n *\n * @NgModule({\n *   declarations: [AppComponent],\n *   imports: [BrowserModule],\n *   providers: [\n *     {\n *       provide: LOCALE_ID,\n *       useFactory: () => {\n *         // Use the browser's language or a default language\n *         return navigator.language || 'en';\n *       },\n *     },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * export class AppModule {}\n */\n\n@Pipe({\n  name: 'byteConverter',\n  standalone: true,\n})\nexport class ByteConverterPipe implements PipeTransform {\n  constructor(@Inject(LOCALE_ID) private locale: string) {}\n\n  // 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.\n  // private locale: string;\n  // constructor() {\n  //   // Use navigator.language as the default locale\n  //   this.locale = navigator.language || 'en';\n  // }\n\n  transform(value: number): string {\n    if (value === null || value === undefined || isNaN(value)) {\n      return '-';\n    }\n\n    const units = ['BYTE', 'KB', 'MB', 'GB', 'TB'];\n    let unitIndex = 0;\n\n    while (value >= 1024 && unitIndex < units.length - 1) {\n      value /= 1024;\n      unitIndex++;\n    }\n\n    const translationObject = translations[this.locale] || translations['en'];\n    const key = units[unitIndex];\n\n    return this.formatNumber(value) + ' ' + translationObject[key];\n  }\n\n  private formatNumber(value: number): string {\n    return new Intl.NumberFormat(this.locale, {maximumFractionDigits: 2}).format(value);\n  }\n}\n\nconst translations: Record<string, Record<string, string>> = {\n  en: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  'en-US': {\n    // You can provide specific variations for en-US if needed\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  de: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  es: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  fr: {\n    BYTE: 'o',\n    KB: 'Ko',\n    MB: 'Mo',\n    GB: 'Go',\n    TB: 'To',\n  },\n  it: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  ja: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  ko: {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  'pt-BR': {\n    BYTE: 'B',\n    KB: 'KB',\n    MB: 'MB',\n    GB: 'GB',\n    TB: 'TB',\n  },\n  'zh-CN': {\n    BYTE: '字节',\n    KB: '千字节',\n    MB: '兆字节',\n    GB: '千兆字节',\n    TB: '太字节',\n  },\n  'zh-TW': {\n    BYTE: '位元組',\n    KB: '千位元組',\n    MB: '兆位元組',\n    GB: '千兆位元組',\n    TB: '太位元組',\n  },\n  ru: {\n    BYTE: 'Б',\n    KB: 'КБ',\n    MB: 'МБ',\n    GB: 'ГБ',\n    TB: 'ТБ',\n  },\n};\n"]}

package/esm2022/lib/pipes/index.mjs

@@ -0,0 +1,5 @@
+export * from './array-join.pipe';
+export * from './byte-converter.pipe';
+export * from './is-https.pipe';
+export * from './mask.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL3BpcGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcnJheS1qb2luLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9ieXRlLWNvbnZlcnRlci5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vaXMtaHR0cHMucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL21hc2sucGlwZSc7XG4iXX0=

package/esm2022/lib/pipes/is-https.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import { httpsPattern } from '../const';
+import * as i0 from "@angular/core";
+export 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,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtaHR0cHMucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1saWZ0L3NyYy9saWIvcGlwZXMvaXMtaHR0cHMucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUVsRCxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0sVUFBVSxDQUFDOztBQU10QyxNQUFNLE9BQU8sV0FBVztJQUN0QixTQUFTLENBQUMsS0FBYTtRQUNyQixPQUFPLFlBQVksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbEMsQ0FBQzs4R0FIVSxXQUFXOzRHQUFYLFdBQVc7OzJGQUFYLFdBQVc7a0JBSnZCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFNBQVM7b0JBQ2YsVUFBVSxFQUFFLElBQUk7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHtodHRwc1BhdHRlcm59IGZyb20gJy4uL2NvbnN0JztcblxuQFBpcGUoe1xuICBuYW1lOiAnaXNIdHRwcycsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIElzSHR0cHNQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIGh0dHBzUGF0dGVybi50ZXN0KHZhbHVlKTtcbiAgfVxufVxuIl19

package/esm2022/lib/pipes/mask.pipe.mjs

@@ -0,0 +1,36 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+const unmaskNumber = 6;
+const maskChar = '*';
+export 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,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/form.util.mjs

@@ -0,0 +1,56 @@
+import { Validators } from '@angular/forms';
+import { of } from 'rxjs';
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,5 @@
+export * from './form.util';
+export * from './is-empty.util';
+export * from './is-equal.util';
+export * from './pick-by.util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mb3JtLnV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9pcy1lbXB0eS51dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vaXMtZXF1YWwudXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2stYnkudXRpbCc7XG4iXX0=

package/esm2022/lib/utils/is-empty.util.mjs

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZW1wdHkudXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1saWZ0L3NyYy9saWIvdXRpbHMvaXMtZW1wdHkudXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBNkMsS0FBMkI7SUFDN0YsSUFBSSxLQUFLLElBQUksSUFBSTtRQUFFLE9BQU8sSUFBSSxDQUFDO0lBRS9CLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUU7UUFDckQsT0FBTyxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztLQUMzQjtJQUVELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO1FBQzdCLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFnQyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztLQUNuRTtJQUVELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ2hlY2sgaWYgYSB2YWx1ZSBpcyBlbXB0eS5cbiAqIEBwYXJhbSB7VCB8IHVuZGVmaW5lZCB8IG51bGx9IHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrIGZvciBlbXB0aW5lc3MuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn0gLSBSZXR1cm5zIHRydWUgaWYgdGhlIHZhbHVlIGlzIGVtcHR5LCBvdGhlcndpc2UgZmFsc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0VtcHR5PFQgZXh0ZW5kcyBvYmplY3QgfCBzdHJpbmcgfCBBcnJheTx1bmtub3duPj4odmFsdWU6IFQgfCB1bmRlZmluZWQgfCBudWxsKTogdmFsdWUgaXMgbnVsbCB7XG4gIGlmICh2YWx1ZSA9PSBudWxsKSByZXR1cm4gdHJ1ZTtcblxuICBpZiAodHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJyB8fCBBcnJheS5pc0FycmF5KHZhbHVlKSkge1xuICAgIHJldHVybiB2YWx1ZS5sZW5ndGggPT09IDA7XG4gIH1cblxuICBpZiAodHlwZW9mIHZhbHVlID09PSAnb2JqZWN0Jykge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyh2YWx1ZSBhcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPikubGVuZ3RoID09PSAwO1xuICB9XG5cbiAgcmV0dXJuIGZhbHNlO1xufVxuIl19

package/esm2022/lib/utils/is-equal.util.mjs

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/pick-by.util.mjs

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGljay1ieS51dGlsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWxpZnQvc3JjL2xpYi91dGlscy9waWNrLWJ5LnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUFJLE1BQVMsRUFBRSxTQUFzRDtJQUN6RixNQUFNLE1BQU0sR0FBZSxFQUFFLENBQUM7SUFFOUIsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLEVBQUU7UUFDeEIsSUFBSSxNQUFNLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxDQUFDLEVBQUU7WUFDcEYsTUFBTSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUMzQjtLQUNGO0lBRUQsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ3JlYXRlIGFuIG9iamVjdCBjb21wb3NlZCBvZiBvYmplY3QgcHJvcGVydGllcyB0aGF0IHNhdGlzZnkgYSBnaXZlbiBjb25kaXRpb24uXG4gKiBAcGFyYW0ge1R9IHNvdXJjZSAtIFRoZSBvYmplY3QgdG8gcGljayBwcm9wZXJ0aWVzIGZyb20uXG4gKiBAcGFyYW0geyh2YWx1ZTogVFtrZXlvZiBUXSwga2V5OiBzdHJpbmcpID0+IGJvb2xlYW59IHByZWRpY2F0ZSAtIFRoZSBmdW5jdGlvbiBpbnZva2VkIHBlciBwcm9wZXJ0eS5cbiAqIEByZXR1cm5zIHtQYXJ0aWFsPFQ+fSAtIFJldHVybnMgdGhlIG5ldyBvYmplY3QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwaWNrQnk8VD4oc291cmNlOiBULCBwcmVkaWNhdGU6ICh2YWx1ZTogVFtrZXlvZiBUXSwga2V5OiBzdHJpbmcpID0+IGJvb2xlYW4pOiBQYXJ0aWFsPFQ+IHtcbiAgY29uc3QgcmVzdWx0OiBQYXJ0aWFsPFQ+ID0ge307XG5cbiAgZm9yIChjb25zdCBrZXkgaW4gc291cmNlKSB7XG4gICAgaWYgKE9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbChzb3VyY2UsIGtleSkgJiYgcHJlZGljYXRlKHNvdXJjZVtrZXldLCBrZXkpKSB7XG4gICAgICByZXN1bHRba2V5XSA9IHNvdXJjZVtrZXldO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiByZXN1bHQ7XG59XG4iXX0=

package/esm2022/lib/validators/index.mjs

@@ -0,0 +1,3 @@
+export * from './unique.validator';
+export * from './url.validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL3ZhbGlkYXRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi91bmlxdWUudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vdXJsLnZhbGlkYXRvcic7XG4iXX0=

package/esm2022/lib/validators/unique.validator.mjs

@@ -0,0 +1,64 @@
+import { FormArray } from '@angular/forms';
+/**
+ * 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.
+ */
+export 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;
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/validators/url.validator.mjs

@@ -0,0 +1,14 @@
+import { httpsPattern, urlPattern } from '../const';
+export function urlValidator(control) {
+    if (!urlPattern.test(control.value)) {
+        return { invalidUrl: true };
+    }
+    return null;
+}
+export function httpsValidator(control) {
+    if (!httpsPattern.test(control.value)) {
+        return { invalidUrl: true };
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1saWZ0L3NyYy9saWIvdmFsaWRhdG9ycy91cmwudmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBQyxZQUFZLEVBQUUsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBRWxELE1BQU0sVUFBVSxZQUFZLENBQUMsT0FBd0I7SUFDbkQsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1FBQ25DLE9BQU8sRUFBQyxVQUFVLEVBQUUsSUFBSSxFQUFDLENBQUM7S0FDM0I7SUFDRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUM7QUFFRCxNQUFNLFVBQVUsY0FBYyxDQUFDLE9BQXdCO0lBQ3JELElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUNyQyxPQUFPLEVBQUMsVUFBVSxFQUFFLElBQUksRUFBQyxDQUFDO0tBQzNCO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnN9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuaW1wb3J0IHtodHRwc1BhdHRlcm4sIHVybFBhdHRlcm59IGZyb20gJy4uL2NvbnN0JztcblxuZXhwb3J0IGZ1bmN0aW9uIHVybFZhbGlkYXRvcihjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzIHwgbnVsbCB7XG4gIGlmICghdXJsUGF0dGVybi50ZXN0KGNvbnRyb2wudmFsdWUpKSB7XG4gICAgcmV0dXJuIHtpbnZhbGlkVXJsOiB0cnVlfTtcbiAgfVxuICByZXR1cm4gbnVsbDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGh0dHBzVmFsaWRhdG9yKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMgfCBudWxsIHtcbiAgaWYgKCFodHRwc1BhdHRlcm4udGVzdChjb250cm9sLnZhbHVlKSkge1xuICAgIHJldHVybiB7aW52YWxpZFVybDogdHJ1ZX07XG4gIH1cbiAgcmV0dXJuIG51bGw7XG59XG4iXX0=

package/esm2022/ngx-lift.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWxpZnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbmd4LWxpZnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,10 @@
+/*
+ * Public API Surface of ngx-lift
+ */
+export * from './lib/models';
+export * from './lib/operators';
+export * from './lib/pipes';
+export * from './lib/utils';
+export * from './lib/validators';
+// export * from './lib/signals';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1saWZ0L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGlDQUFpQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LWxpZnRcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvb3BlcmF0b3JzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BpcGVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3ZhbGlkYXRvcnMnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9saWIvc2lnbmFscyc7XG4iXX0=