ngx-lift 1.0.0 → 1.2.0

package/fesm2022/ngx-lift.mjs

@@ -1,6 +1,8 @@
-import { startWith, Subject, combineLatest, pipe, tap, map, catchError, of, Observable, merge, EMPTY, timer, exhaustMap, share, switchMap, isObservable, switchAll, mergeAll, concatAll, exhaustAll } from 'rxjs';
+import { startWith, Subject, combineLatest, pipe, tap, map, catchError, of, Observable, merge, EMPTY, timer, exhaustMap, share, switchMap, identity, isObservable, distinctUntilChanged, from, switchAll, mergeAll, concatAll, exhaustAll } from 'rxjs';
 import * as i0 from '@angular/core';
-import { Pipe, LOCALE_ID, Inject, inject, DestroyRef, signal, effect, untracked, computed } from '@angular/core';
+import { Pipe, inject, LOCALE_ID, assertInInjectionContext, isSignal, untracked, computed, DestroyRef, signal, effect } from '@angular/core';
+import { toSignal, toObservable } from '@angular/core/rxjs-interop';
+import { ActivatedRoute } from '@angular/router';
 import { Validators, FormArray } from '@angular/forms';
 
 /**
@@ -285,10 +287,10 @@ class ArrayJoinPipe {
         // 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.3.4", ngImport: i0, type: ArrayJoinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.4", ngImport: i0, type: ArrayJoinPipe, isStandalone: true, name: "arrayJoin" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ArrayJoinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.10", ngImport: i0, type: ArrayJoinPipe, isStandalone: true, name: "arrayJoin" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ArrayJoinPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ArrayJoinPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'arrayJoin',
@@ -326,8 +328,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImpor
  * export class AppModule {}
  */
 class ByteConverterPipe {
-    constructor(locale) {
-        this.locale = locale;
+    constructor() {
+        this.locale = inject(LOCALE_ID);
     }
     // 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;
@@ -352,19 +354,16 @@ class ByteConverterPipe {
     formatNumber(value) {
         return new Intl.NumberFormat(this.locale, { maximumFractionDigits: 2 }).format(value);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ByteConverterPipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.4", ngImport: i0, type: ByteConverterPipe, isStandalone: true, name: "byteConverter" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ByteConverterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.10", ngImport: i0, type: ByteConverterPipe, isStandalone: true, name: "byteConverter" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ByteConverterPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", 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',
@@ -462,10 +461,10 @@ class IsHttpsPipe {
     transform(value) {
         return httpsPattern.test(value);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: IsHttpsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.4", ngImport: i0, type: IsHttpsPipe, isStandalone: true, name: "isHttps" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: IsHttpsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.10", ngImport: i0, type: IsHttpsPipe, isStandalone: true, name: "isHttps" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: IsHttpsPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: IsHttpsPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'isHttps',
@@ -496,10 +495,10 @@ class MaskPipe {
             .map((char, i) => (i < unmaskedPrefixLength || i > value.length - unmaskedSuffixLength - 1 ? char : maskChar))
             .join('');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: MaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.4", ngImport: i0, type: MaskPipe, isStandalone: true, name: "mask" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: MaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.10", ngImport: i0, type: MaskPipe, isStandalone: true, name: "mask" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: MaskPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: MaskPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'mask',
@@ -507,6 +506,84 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImpor
                 }]
         }] });
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Combines multiple `Observable` or `Signal` sources into a `Signal` that emits their values. It's like combineLatest.
+ *
+ * @param {ObservableSignalInputTuple} sources - Array or object of `Observable` or `Signal` values
+ * @param {OperatorFunction} [operator] - Operator to apply to the combined values
+ * @param {CombineFromOptions} [options] - Options including `initialValue` and `injector`
+ * @returns Signal emitting the combined values
+ *
+ * @example
+ * ```ts
+ * export class Component {
+ *  private readonly userService = inject(UserService);
+ *  page = signal(2);
+ *
+ *  data = combineFrom(
+ *    [this.page, this.userService.users$],
+ *    pipe(
+ *      switchMap(([page, users]) => this.dataService.getData(page, users)),
+ *      startWith([])
+ *    )
+ *  );
+ * }
+ * ```
+ */
+function combineFrom(...args) {
+    assertInInjectionContext(combineFrom);
+    const { normalizedSources, hasInitValue, operator, options } = normalizeArgs(args);
+    const ret = hasInitValue
+        ? toSignal(combineLatest(normalizedSources).pipe(operator), {
+            initialValue: options.initialValue,
+            injector: options?.injector,
+        })
+        : toSignal(combineLatest(normalizedSources).pipe(operator), {
+            injector: options?.injector,
+            // requireSync: true,
+        });
+    return ret;
+}
+function normalizeArgs(args) {
+    if (!args || args.length < 1 || typeof args[0] !== 'object') {
+        throw new TypeError('combineFrom needs sources');
+    }
+    const hasOperator = typeof args[1] === 'function';
+    if (args.length === 3 && !hasOperator) {
+        throw new TypeError('combineFrom needs a pipe operator as the second argument');
+    }
+    // pass sources and options
+    if (!hasOperator) {
+        // add identity function to args at index 1 as operator function as x=>x
+        args.splice(1, 0, identity);
+    }
+    // if no operator passed, identity will be operator
+    const [sources, operator, options] = args;
+    const hasInitValue = options?.initialValue !== undefined;
+    const normalizedSources = Object.entries(sources).reduce((acc, [keyOrIndex, source]) => {
+        if (isSignal(source)) {
+            acc[keyOrIndex] = toObservable(source, { injector: options?.injector }).pipe(
+            // toObservable doesn't immediately emit initialValue of the signal
+            startWith(untracked(source)));
+        }
+        else if (isObservable(source)) {
+            acc[keyOrIndex] = source.pipe(distinctUntilChanged());
+        }
+        else if (typeof source === 'function') {
+            // seldom use: pass function like () => 5
+            const computedRes = computed(source);
+            acc[keyOrIndex] = toObservable(computedRes, { injector: options?.injector }).pipe(startWith(source()));
+        }
+        else {
+            // seldom use: pass promise, Map, array, etc that from accepts
+            acc[keyOrIndex] = from(source).pipe(distinctUntilChanged());
+        }
+        return acc;
+    }, (Array.isArray(sources) ? [] : {}));
+    return { normalizedSources, operator, hasInitValue, options };
+}
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 function computedAsync(computeFn, options = {}) {
     const destroyRef = inject(DestroyRef);
@@ -578,6 +655,154 @@ function createNotifier() {
     };
 }
 
+function injectParams(keyOrParamsTransform, options = {}) {
+    assertInInjectionContext(injectParams);
+    const route = inject(ActivatedRoute);
+    const initialParams = route.snapshot.params;
+    const { transform, initialValue } = options;
+    // injectParams(): Signal<Params>
+    if (!keyOrParamsTransform) {
+        return toSignal(route.params, { initialValue: initialParams });
+    }
+    // injectParams<Output>(fn: ParamsTransformFn<Output>): Signal<Output>
+    if (typeof keyOrParamsTransform === 'function') {
+        return toSignal(route.params.pipe(map(keyOrParamsTransform)), { initialValue: keyOrParamsTransform(initialParams) });
+    }
+    // keyOrParamsTransform is string.
+    // export function injectParams(key: string): Signal<string | null>;
+    // export function injectParams(key: string, options: { transform: (v: string) => boolean; initialValue: boolean }): Signal<boolean>;
+    // export function injectParams(key: string, options: { transform: (v: string) => number; initialValue: number }): Signal<number>;
+    // export function injectParams(key: string, options: { transform?: (v: string) => string; initialValue: string }): Signal<string>;
+    // export function injectParams(key: string, options: { transform: (v: string) => boolean; initialValue?: undefined }): Signal<boolean | null>;
+    // export function injectParams(key: string, options: { transform: (v: string) => number; initialValue?: undefined }): Signal<number | null>;
+    // export function injectParams(key: string, options: { transform: (v: string) => string; initialValue?: undefined }): Signal<string | null>;
+    const getParam = (params) => {
+        const param = params?.[keyOrParamsTransform];
+        if (!param) {
+            return initialValue ?? null;
+        }
+        return transform ? transform(param) : param;
+    };
+    return toSignal(route.params.pipe(map(getParam)), { initialValue: getParam(initialParams) });
+}
+
+/**
+ * The `injectQueryParams` function allows you to access and manipulate query parameters from the current route.
+ *
+ * @template Output - The expected type of the read value.
+ * @param {string} keyOrParamsTransform - The name of the query parameter to retrieve, or a transform function to apply to the query parameters object.
+ * @param {QueryParamsOptions} options - Optional configuration options for the query parameter.
+ * @returns {QueryParamsOptions} A `Signal` that emits the transformed value of the specified query parameter, or the entire query parameters object if no key is provided.
+ *
+ * @example
+ * const search = injectQueryParams('search'); // returns the value of the 'search' query param
+ * const search = injectQueryParams(p => p['search'] as string); // same as above but can be used with a custom transform function
+ * const idParam = injectQueryParams('id', {transform: numberAttribute}); // returns the value fo the 'id' query params and transforms it into a number
+ * const idParam = injectQueryParams(p => numberAttribute(p['id'])); // same as above but can be used with a custom transform function
+ * const queryParams = injectQueryParams(); // returns the entire query params object
+ */
+function injectQueryParams(keyOrParamsTransform, options = {}) {
+    assertInInjectionContext(injectQueryParams);
+    const route = inject(ActivatedRoute);
+    const initialQueryParams = route.snapshot.queryParams;
+    const { transform, initialValue } = options;
+    // injectQueryParams(): Signal<Params>
+    if (!keyOrParamsTransform) {
+        return toSignal(route.queryParams, { initialValue: initialQueryParams });
+    }
+    // injectQueryParams<Output>(fn: QueryParamsTransformFn<Output>): Signal<Output>
+    if (typeof keyOrParamsTransform === 'function') {
+        return toSignal(route.queryParams.pipe(map(keyOrParamsTransform)), {
+            initialValue: keyOrParamsTransform(initialQueryParams),
+        });
+    }
+    // keyOrParamsTransform is string.
+    const getParam = (params) => {
+        const param = params?.[keyOrParamsTransform];
+        if (!param) {
+            return initialValue ?? null;
+        }
+        if (Array.isArray(param)) {
+            if (param.length < 1) {
+                return initialValue ?? null;
+            }
+            return transform ? transform(param[0]) : param[0];
+        }
+        return transform ? transform(param) : param;
+    };
+    return toSignal(route.queryParams.pipe(map(getParam)), {
+        initialValue: getParam(initialQueryParams),
+    });
+}
+
+// No object inputs
+/**
+ * merge multiple `Observable` or `Signal` sources into a `Signal` that emits the last value. It's like merge.
+ *
+ * @param {ObservableSignalInputTuple} sources - Array of `Observable` or `Signal` values
+ * @param {OperatorFunction} [operator] - Operator to apply to the merge
+ * @param {MergeFromOptions} [options] - Options including `initialValue` and `injector`
+ * @returns Signal emitting the latest merge result
+ *
+ * @example
+ * ```ts
+ * export class Component {
+ *   e$ = of(1).pipe(delay(1000));
+ *   f = signal(2);
+ *
+ *   data = mergeFrom(
+ *     [this.e$, this.f],
+ *     pipe(
+ *       switchMap((res) => of(`${res} is coming~`)),
+ *       startWith(0),
+ *     ),
+ *   );
+ * }
+ * ```
+ */
+function mergeFrom(...args) {
+    assertInInjectionContext(mergeFrom);
+    const [sources, operator = identity, options = {}] = parseArgs(args);
+    const normalizedSources = sources.map((source) => {
+        if (isSignal(source)) {
+            return toObservable(source, { injector: options.injector }).pipe(startWith(untracked(source)));
+        }
+        if (!isObservable(source)) {
+            source = from(source);
+        }
+        return source.pipe(distinctUntilChanged());
+    });
+    const merged$ = merge(...normalizedSources).pipe(operator);
+    if (options.initialValue !== undefined) {
+        return toSignal(merged$, { initialValue: options.initialValue, injector: options.injector });
+    }
+    return toSignal(merged$, { requireSync: true, injector: options.injector });
+}
+function parseArgs(args) {
+    if (!args || args.length < 1) {
+        throw new TypeError('mergeFrom needs sources');
+    }
+    if (args.length === 1) {
+        return [args[0], undefined, undefined];
+    }
+    if (args.length === 2) {
+        const hasOperator = typeof args[1] === 'function';
+        if (hasOperator) {
+            return [
+                args[0],
+                args[1],
+                undefined,
+            ];
+        }
+        return [
+            args[0],
+            undefined,
+            args[1],
+        ];
+    }
+    return args;
+}
+
 /**
  * Calculates the difference in whole days between two dates.
  *
@@ -795,5 +1020,5 @@ function httpsValidator(control) {
  * Generated bundle index. Do not edit.
  */
 
-export { ArrayJoinPipe, ByteConverterPipe, IsHttpsPipe, MaskPipe, UniqueValidator, combineLatestEager, computedAsync, createAsyncState, createNotifier, differenceInDays, distinctOnChange, httpsValidator, ifAsyncValidator, ifValidator, isEmpty, isEqual, logger, pickBy, poll, startWithTap, switchMapWithAsyncState, urlValidator };
+export { ArrayJoinPipe, ByteConverterPipe, IsHttpsPipe, MaskPipe, UniqueValidator, combineFrom, combineLatestEager, computedAsync, createAsyncState, createNotifier, differenceInDays, distinctOnChange, httpsValidator, ifAsyncValidator, ifValidator, injectParams, injectQueryParams, isEmpty, isEqual, logger, mergeFrom, pickBy, poll, startWithTap, switchMapWithAsyncState, urlValidator };
 //# sourceMappingURL=ngx-lift.mjs.map