ngx-lift 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 wghglory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# Welcome to [ngx-lift](https://ngx-lift.netlify.app/)!
+
+Welcome to ngx-lift! This project has been crafted with the goal of enhancing and simplifying your Angular development
+experience. In the dynamic landscape of web development, Angular stands out as a robust framework, and ngx-lift
+complements it by offering a collection of utilities, operators, and components. Welcome to ngx-lift, a powerful Angular
+lift designed to enhance your development workflow. Explore its capabilities through our demo site and dive into the
+source code on GitHub.
+
+## Key Objectives
+
+- **Utility Enhancement:** ngx-lift strives to provide a set of utilities that streamline common Angular development
+  tasks. These utilities are designed to boost your productivity and efficiency.
+
+- **Operator Support:** The project includes a range of operators that can be seamlessly integrated into your Angular
+  applications. These operators aim to simplify complex operations and promote cleaner, more maintainable code.
+
+- **Component Repository:** ngx-lift comes bundled with a collection of reusable components. These components are
+  crafted with best practices in mind, allowing you to effortlessly integrate them into your projects and focus on
+  building outstanding user interfaces.
+
+## Why Choose ngx-lift?
+
+- **Simplified Development:** Our project is dedicated to simplifying the Angular development process, empowering
+  developers to build robust applications with ease.
+
+- **Community-Driven:** ngx-lift is an open-source project, and we welcome contributions from the community. Join us in
+  shaping the future of Angular development tools.
+
+- **Continuous Improvement:** We are committed to continuous improvement and aim to adapt to the evolving needs of the
+  Angular ecosystem. Your feedback and contributions are invaluable in this journey.
+
+## Requirements
+
+To ensure optimal performance and compatibility, ngx-lift requires **Angular version 15 or higher**.
+
+## Get Started
+
+Explore its capabilities through our demo site and dive into the source code on GitHub.
+
+### Demo Site
+
+To experience the full potential of ngx-lift, visit our demo site at
+[https://ngx-lift.netlify.app/](https://ngx-lift.netlify.app/). The demo showcases various features and functionalities,
+providing an interactive way to understand the capabilities of ngx-lift.
+
+### Source Code
+
+For a deeper understanding of ngx-lift, review the source code available on GitHub:
+[https://github.com/wghglory/ngx-lift/tree/master/projects/ngx-lift](https://github.com/wghglory/ngx-lift/tree/master/projects/ngx-lift).
+Clone the repository to your local environment and explore the demos provided. Gain insights into how ngx-lift can
+elevate your Angular development workflow by examining the codebase and incorporating it into your projects.
+
+Thank you for considering ngx-lift for your Angular projects. We look forward to your involvement and feedback as we
+collectively strive to enhance the Angular development experience.
+
+Happy coding!

package/esm2022/lib/const.mjs

@@ -0,0 +1,5 @@
+// https://regex101.com/library/mX1xW0
+export const emailPattern = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/;
+export const urlPattern = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+export const httpsPattern = /^https:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL2NvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHNDQUFzQztBQUN0QyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsbUZBQW1GLENBQUM7QUFFaEgsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUNyQiwwR0FBMEcsQ0FBQztBQUM3RyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQ3ZCLHlHQUF5RyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cHM6Ly9yZWdleDEwMS5jb20vbGlicmFyeS9tWDF4VzBcbmV4cG9ydCBjb25zdCBlbWFpbFBhdHRlcm4gPSAvXihbXFx3LV0rKD86XFwuW1xcdy1dKykqKUAoKD86W1xcdy1dK1xcLikqXFx3W1xcdy1dezAsNjZ9KVxcLihbYS16XXsyLDZ9KD86XFwuW2Etel17Mn0pPykkLztcblxuZXhwb3J0IGNvbnN0IHVybFBhdHRlcm4gPVxuICAvXmh0dHBzPzpcXC9cXC8oPzp3d3dcXC4pP1stYS16QS1aMC05QDolLl8rfiM9XXsxLDI1Nn1cXC5bYS16QS1aMC05KCldezEsNn1cXGIoPzpbLWEtekEtWjAtOSgpQDolXysufiM/Ji89XSopJC87XG5leHBvcnQgY29uc3QgaHR0cHNQYXR0ZXJuID1cbiAgL15odHRwczpcXC9cXC8oPzp3d3dcXC4pP1stYS16QS1aMC05QDolLl8rfiM9XXsxLDI1Nn1cXC5bYS16QS1aMC05KCldezEsNn1cXGIoPzpbLWEtekEtWjAtOSgpQDolXysufiM/Ji89XSopJC87XG4iXX0=

package/esm2022/lib/models/async-state.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMtc3RhdGUubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL21vZGVscy9hc3luYy1zdGF0ZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtIdHRwRXJyb3JSZXNwb25zZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuXG4vKipcbiAqIFJlcHJlc2VudHMgdGhlIHN0YXRlIG9mIGFuIGFzeW5jaHJvbm91cyBvcGVyYXRpb24sIGluY2x1ZGluZyBsb2FkaW5nLCBlcnJvciwgYW5kIGRhdGEuXG4gKiBAdGVtcGxhdGUgVCAtIFRoZSB0eXBlIG9mIHRoZSBkYXRhIGluIHRoZSByZXNwb25zZS5cbiAqIEB0ZW1wbGF0ZSBFIC0gVGhlIHR5cGUgb2YgdGhlIGVycm9yIHJlc3BvbnNlLCBkZWZhdWx0aW5nIHRvIGBIdHRwRXJyb3JSZXNwb25zZWAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQXN5bmNTdGF0ZTxULCBFID0gSHR0cEVycm9yUmVzcG9uc2U+IHtcbiAgLyoqXG4gICAqIEluZGljYXRlcyB3aGV0aGVyIHRoZSBhc3luY2hyb25vdXMgb3BlcmF0aW9uIGlzIGluIHByb2dyZXNzLlxuICAgKi9cbiAgbG9hZGluZzogYm9vbGVhbjtcblxuICAvKipcbiAgICogUmVwcmVzZW50cyBhbnkgZXJyb3IgdGhhdCBvY2N1cnJlZCBkdXJpbmcgdGhlIGFzeW5jaHJvbm91cyBvcGVyYXRpb24uXG4gICAqIE51bGwgaWYgbm8gZXJyb3Igb2NjdXJyZWQuXG4gICAqL1xuICBlcnJvcjogRSB8IG51bGw7XG5cbiAgLyoqXG4gICAqIFRoZSBkYXRhIHJlc3VsdGluZyBmcm9tIHRoZSBhc3luY2hyb25vdXMgb3BlcmF0aW9uLlxuICAgKiBOdWxsIGlmIHRoZSBvcGVyYXRpb24gaGFzIG5vdCBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5LlxuICAgKi9cbiAgZGF0YTogVCB8IG51bGw7XG59XG4iXX0=

package/esm2022/lib/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './async-state.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hc3luYy1zdGF0ZS5tb2RlbCc7XG4iXX0=

package/esm2022/lib/operators/combine-latest-eager.operator.mjs

@@ -0,0 +1,48 @@
+import { combineLatest, startWith, Subject } from 'rxjs';
+/**
+ * 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.
+ */
+export 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}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/operators/create-async-state.operator.mjs

@@ -0,0 +1,52 @@
+import { catchError, map, of, pipe, startWith, tap } from 'rxjs';
+/**
+ * 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 })),
+ *     ),
+ *   ))
+ * )
+ *
+ */
+export 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 })));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/operators/distinct-on-change.operator.mjs

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+/**
+ * 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)),
+ * );
+ */
+export 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();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/operators/index.mjs

@@ -0,0 +1,8 @@
+export * from './combine-latest-eager.operator';
+export * from './create-async-state.operator';
+export * from './distinct-on-change.operator';
+export * from './logger.operator';
+export * from './poll.operator';
+export * from './start-with-tap.operator';
+export * from './switch-map-with-async-state.operator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL29wZXJhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21iaW5lLWxhdGVzdC1lYWdlci5vcGVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1hc3luYy1zdGF0ZS5vcGVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2Rpc3RpbmN0LW9uLWNoYW5nZS5vcGVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlci5vcGVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3BvbGwub3BlcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFydC13aXRoLXRhcC5vcGVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3N3aXRjaC1tYXAtd2l0aC1hc3luYy1zdGF0ZS5vcGVyYXRvcic7XG4iXX0=

package/esm2022/lib/operators/logger.operator.mjs

@@ -0,0 +1,21 @@
+import { pipe, tap } from 'rxjs';
+// 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.
+ */
+export const logger = (loggerType = 'log') => pipe(tap((value) => {
+    const logFunction = loggerFunctions[loggerType] || console.log.bind(console);
+    logFunction(value);
+}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/operators/poll.operator.mjs

@@ -0,0 +1,32 @@
+import { catchError, EMPTY, exhaustMap, map, merge, of, share, startWith, timer } from 'rxjs';
+/**
+ * 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
+ */
+export 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());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/operators/start-with-tap.operator.mjs

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export function startWithTap(callback) {
+    return (source) => {
+        callback();
+        return source;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQtd2l0aC10YXAub3BlcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGlmdC9zcmMvbGliL29wZXJhdG9ycy9zdGFydC13aXRoLXRhcC5vcGVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBSSxRQUFvQjtJQUNsRCxPQUFPLENBQUMsTUFBcUIsRUFBRSxFQUFFO1FBQy9CLFFBQVEsRUFBRSxDQUFDO1FBQ1gsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T2JzZXJ2YWJsZX0gZnJvbSAncnhqcyc7XG5cbi8qKlxuICogT3BlcmF0b3IgdGhhdCB0YXBzIGludG8gYSBjYWxsYmFjayBiZWZvcmUgdGhlIHNvdXJjZSBPYnNlcnZhYmxlIHN0YXJ0cyBlbWl0dGluZyB2YWx1ZXMuXG4gKlxuICogVGhpcyBvcGVyYXRvciBpcyB1c2VmdWwgZm9yIHRyaWdnZXJpbmcgYSBzaWRlIGVmZmVjdCBiZWZvcmUgdGhlIG1haW4gT2JzZXJ2YWJsZSBzdGFydHMgZW1pdHRpbmcuXG4gKlxuICogQHBhcmFtIGNhbGxiYWNrIEEgZnVuY3Rpb24gdG8gYmUgZXhlY3V0ZWQgYmVmb3JlIHRoZSBzb3VyY2UgT2JzZXJ2YWJsZSBlbWl0cyBpdHMgZmlyc3QgdmFsdWUuXG4gKiBAcmV0dXJucyBBbiBSeEpTIG9wZXJhdG9yIGZ1bmN0aW9uIHRoYXQgdGFwcyBpbnRvIHRoZSBjYWxsYmFjayBhbmQgdGhlbiBzd2l0Y2hNYXBzIHRvIHRoZSBzb3VyY2UgT2JzZXJ2YWJsZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHN0YXJ0V2l0aFRhcDxUPihjYWxsYmFjazogKCkgPT4gdm9pZCkge1xuICByZXR1cm4gKHNvdXJjZTogT2JzZXJ2YWJsZTxUPikgPT4ge1xuICAgIGNhbGxiYWNrKCk7XG4gICAgcmV0dXJuIHNvdXJjZTtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/lib/operators/switch-map-with-async-state.operator.mjs

@@ -0,0 +1,33 @@
+import { switchMap } from 'rxjs';
+import { createAsyncState } from './create-async-state.operator';
+/**
+ * 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.
+ * });
+ */
+export function switchMapWithAsyncState(project) {
+    return (source) => source.pipe(switchMap((value, index) => project(value, index).pipe(createAsyncState())));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pipes/array-join.pipe.mjs

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