@odx/angular 6.0.0 → 6.0.1

package/esm2022/utils/lib/helpers/queue.mjs

@@ -4,6 +4,13 @@ import { isNumber, isString } from './type-guards';
 function isQueueItemId(value) {
     return isString(value) || isNumber(value);
 }
+/**
+ * A class representing a queue structure with advanced functionalities including adding, removing,
+ * updating items, and observing changes through RxJS observables. It supports generic queue item types,
+ * allowing for flexible usage across different contexts.
+ *
+ * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.
+ */
 export class Queue {
     constructor() {
         this.queue = new Map();
@@ -11,29 +18,82 @@ export class Queue {
         this.values = [];
         this.firstItem = null;
         this.lastItem = null;
+        /**
+         * An observable that emits when an item is added to the queue.
+         * @type {Observable<T>}
+         */
         this.onAdd$ = this.createEventObserver('add');
+        /**
+         * An observable that emits when an item in the queue is updated.
+         * @type {Observable<T>}
+         */
         this.onUpdate$ = this.createEventObserver('update');
+        /**
+         * An observable that emits when an item is removed from the queue.
+         * @type {Observable<T>}
+         */
         this.onRemove$ = this.createEventObserver('remove');
+        /**
+         * An observable representing the current state of the queue as an array of items.
+         * @type {Observable<QueueItem<T>[]>}
+         */
         this.value$ = this.events$$.pipe(startWith(() => void 0), map(() => this.values), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * An observable that emits the current size of the queue.
+         * @type {Observable<number>}
+         */
         this.size$ = this.value$.pipe(map(() => this.size), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Gets the size of the queue.
+     * @returns The number of elements in the queue.
+     */
     get size() {
         return this.queue.size;
     }
+    /**
+     * Checks if the specified item is the first item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.
+     */
     isFirst({ id }) {
         return this.firstItem?.id === id;
     }
+    /**
+     * Checks if the specified item is the last item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.
+     */
     isLast({ id }) {
         return this.lastItem?.id === id;
     }
+    /**
+     * Retrieves a queue item from the queue based on the provided item or item ID.
+     * @param itemOrId - The queue item or item ID to retrieve.
+     * @returns The queue item if found, or `null` if not found.
+     */
     get(itemOrId) {
         const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();
         return this.queue.get(id) ?? null;
     }
+    /**
+     * Adds an item to the queue, optionally emitting an event.
+     *
+     * @param {QueueItem<T>} item - The item to add.
+     * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.
+     * @returns {QueueItem<T>} The item added to the queue.
+     */
     add(item, emitEvent = true) {
         this.remove(item, false);
         return this.addMany([item], emitEvent)[0];
     }
+    /**
+     * Adds multiple items to the queue.
+     *
+     * @param items - An array of items to be added to the queue.
+     * @param emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.
+     * @returns An array of added items.
+     */
     addMany(items, emitEvent = true) {
         const addedItems = [];
         const updatedItems = [];
@@ -54,9 +114,22 @@ export class Queue {
         }
         return items;
     }
+    /**
+     * Removes an item from the queue.
+     *
+     * @param itemOrId - The item or ID of the item to be removed.
+     * @param emitEvent - Whether to emit an event after removing the item. Default is `true`.
+     * @returns The removed item, or `null` if the item was not found.
+     */
     remove(itemOrId, emitEvent = true) {
         return this.removeMany([itemOrId], emitEvent)[0];
     }
+    /**
+     * Removes multiple items from the queue based on the provided item or item IDs.
+     * @param itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.
+     * @param emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.
+     * @returns An array of removed QueueItem objects or null values.
+     */
     removeMany(itemOrIds, emitEvent = true) {
         const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean);
         const removedItems = [];
@@ -69,11 +142,21 @@ export class Queue {
         this.notify({ type: 'remove', items: removedItems }, emitEvent);
         return items;
     }
+    /**
+     * Clears the queue by removing all items.
+     *
+     * @param emitEvent - Whether to emit an event after clearing the queue. Default is true.
+     */
     clear(emitEvent = true) {
         const items = this.toArray();
         this.queue.clear();
         this.notify({ type: 'remove', items }, emitEvent);
     }
+    /**
+     * Returns an array representation of the queue.
+     *
+     * @returns An array containing all the items in the queue.
+     */
     toArray() {
         return this.values;
     }
@@ -89,4 +172,4 @@ export class Queue {
         return this.events$$.pipe(filter((event) => event.type === type), map(({ items }) => items), concatAll(), share());
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject } from 'rxjs';\nimport { concatAll, distinctUntilChanged, filter, map, share, shareReplay, startWith } from 'rxjs/operators';\nimport { isNumber, isString } from './type-guards';\n\ntype QueueItemId = string | number;\ntype QueueItem<T> = T & { id: QueueItemId };\ntype QueueEventType = 'remove' | 'add' | 'update';\ntype QueueEvent<T> = { items: QueueItem<T>[]; type: QueueEventType };\n\nfunction isQueueItemId(value: unknown): value is QueueItemId {\n  return isString(value) || isNumber(value);\n}\n\nexport class Queue<T> {\n  private readonly queue = new Map<string, QueueItem<T>>();\n  private readonly events$$ = new Subject<QueueEvent<T>>();\n  private values: QueueItem<T>[] = [];\n  private firstItem: QueueItem<T> | null = null;\n  private lastItem: QueueItem<T> | null = null;\n\n  public readonly onAdd$ = this.createEventObserver('add');\n  public readonly onUpdate$ = this.createEventObserver('update');\n  public readonly onRemove$ = this.createEventObserver('remove');\n  public readonly value$ = this.events$$.pipe(\n    startWith(() => void 0),\n    map(() => this.values),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly size$ = this.value$.pipe(\n    map(() => this.size),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  public get size(): number {\n    return this.queue.size;\n  }\n\n  public isFirst({ id }: QueueItem<T>): boolean {\n    return this.firstItem?.id === id;\n  }\n\n  public isLast({ id }: QueueItem<T>): boolean {\n    return this.lastItem?.id === id;\n  }\n\n  public get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null {\n    const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();\n\n    return this.queue.get(id) ?? null;\n  }\n\n  public add(item: QueueItem<T>, emitEvent = true): QueueItem<T> {\n    this.remove(item, false);\n\n    return this.addMany([item], emitEvent)[0];\n  }\n\n  public addMany(items: Array<QueueItem<T>>, emitEvent = true): Array<QueueItem<T>> {\n    const addedItems = [];\n    const updatedItems = [];\n    for (const item of items) {\n      if (this.get(item)) {\n        addedItems.push(item);\n      } else {\n        updatedItems.push(item);\n      }\n      this.queue.set(item.id.toString(), item);\n    }\n    if (addedItems.length) {\n      this.notify({ type: 'add', items: addedItems }, emitEvent);\n    }\n    if (updatedItems.length) {\n      this.notify({ type: 'update', items: updatedItems }, emitEvent);\n    }\n\n    return items;\n  }\n\n  public remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent = true): QueueItem<T> | null {\n    return this.removeMany([itemOrId], emitEvent)[0];\n  }\n\n  public removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent = true): Array<QueueItem<T> | null> {\n    const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean) as QueueItem<T>[];\n    const removedItems = [];\n    for (const item of items) {\n      const itemRemoved = this.queue.delete(item.id.toString());\n      if (!itemRemoved) continue;\n      removedItems.push(item);\n    }\n    this.notify({ type: 'remove', items: removedItems }, emitEvent);\n\n    return items;\n  }\n\n  public clear(emitEvent = true): void {\n    const items = this.toArray();\n    this.queue.clear();\n    this.notify({ type: 'remove', items }, emitEvent);\n  }\n\n  public toArray(): QueueItem<T>[] {\n    return this.values;\n  }\n\n  private notify(event: QueueEvent<T>, emitEvent = true): void {\n    this.values = Array.from(this.queue, ([_, item]) => item).reverse();\n    this.firstItem = this.values[0] ?? null;\n    this.lastItem = this.values[this.values.length - 1] ?? null;\n    if (!emitEvent) return;\n    this.events$$.next(event);\n  }\n\n  private createEventObserver(type: QueueEventType): Observable<T> {\n    return this.events$$.pipe(\n      filter((event) => event.type === type),\n      map(({ items }) => items),\n      concatAll(),\n      share(),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject } from 'rxjs';\nimport { concatAll, distinctUntilChanged, filter, map, share, shareReplay, startWith } from 'rxjs/operators';\nimport { isNumber, isString } from './type-guards';\n\ntype QueueItemId = string | number;\ntype QueueItem<T> = T & { id: QueueItemId };\ntype QueueEventType = 'remove' | 'add' | 'update';\ntype QueueEvent<T> = { items: QueueItem<T>[]; type: QueueEventType };\n\nfunction isQueueItemId(value: unknown): value is QueueItemId {\n  return isString(value) || isNumber(value);\n}\n\n/**\n * A class representing a queue structure with advanced functionalities including adding, removing,\n * updating items, and observing changes through RxJS observables. It supports generic queue item types,\n * allowing for flexible usage across different contexts.\n *\n * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.\n */\nexport class Queue<T> {\n  private readonly queue = new Map<string, QueueItem<T>>();\n  private readonly events$$ = new Subject<QueueEvent<T>>();\n  private values: QueueItem<T>[] = [];\n  private firstItem: QueueItem<T> | null = null;\n  private lastItem: QueueItem<T> | null = null;\n\n  /**\n   * An observable that emits when an item is added to the queue.\n   * @type {Observable<T>}\n   */\n  public readonly onAdd$ = this.createEventObserver('add');\n\n  /**\n   * An observable that emits when an item in the queue is updated.\n   * @type {Observable<T>}\n   */\n  public readonly onUpdate$ = this.createEventObserver('update');\n\n  /**\n   * An observable that emits when an item is removed from the queue.\n   * @type {Observable<T>}\n   */\n  public readonly onRemove$ = this.createEventObserver('remove');\n\n  /**\n   * An observable representing the current state of the queue as an array of items.\n   * @type {Observable<QueueItem<T>[]>}\n   */\n  public readonly value$ = this.events$$.pipe(\n    startWith(() => void 0),\n    map(() => this.values),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * An observable that emits the current size of the queue.\n   * @type {Observable<number>}\n   */\n  public readonly size$ = this.value$.pipe(\n    map(() => this.size),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Gets the size of the queue.\n   * @returns The number of elements in the queue.\n   */\n  public get size(): number {\n    return this.queue.size;\n  }\n\n  /**\n   * Checks if the specified item is the first item in the queue.\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.\n   */\n  public isFirst({ id }: QueueItem<T>): boolean {\n    return this.firstItem?.id === id;\n  }\n\n  /**\n   * Checks if the specified item is the last item in the queue.\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.\n   */\n  public isLast({ id }: QueueItem<T>): boolean {\n    return this.lastItem?.id === id;\n  }\n\n  /**\n   * Retrieves a queue item from the queue based on the provided item or item ID.\n   * @param itemOrId - The queue item or item ID to retrieve.\n   * @returns The queue item if found, or `null` if not found.\n   */\n  public get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null {\n    const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();\n\n    return this.queue.get(id) ?? null;\n  }\n\n  /**\n   * Adds an item to the queue, optionally emitting an event.\n   *\n   * @param {QueueItem<T>} item - The item to add.\n   * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.\n   * @returns {QueueItem<T>} The item added to the queue.\n   */\n  public add(item: QueueItem<T>, emitEvent = true): QueueItem<T> {\n    this.remove(item, false);\n\n    return this.addMany([item], emitEvent)[0];\n  }\n\n  /**\n   * Adds multiple items to the queue.\n   *\n   * @param items - An array of items to be added to the queue.\n   * @param emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.\n   * @returns An array of added items.\n   */\n  public addMany(items: Array<QueueItem<T>>, emitEvent = true): Array<QueueItem<T>> {\n    const addedItems = [];\n    const updatedItems = [];\n    for (const item of items) {\n      if (this.get(item)) {\n        addedItems.push(item);\n      } else {\n        updatedItems.push(item);\n      }\n      this.queue.set(item.id.toString(), item);\n    }\n    if (addedItems.length) {\n      this.notify({ type: 'add', items: addedItems }, emitEvent);\n    }\n    if (updatedItems.length) {\n      this.notify({ type: 'update', items: updatedItems }, emitEvent);\n    }\n\n    return items;\n  }\n\n  /**\n   * Removes an item from the queue.\n   *\n   * @param itemOrId - The item or ID of the item to be removed.\n   * @param emitEvent - Whether to emit an event after removing the item. Default is `true`.\n   * @returns The removed item, or `null` if the item was not found.\n   */\n  public remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent = true): QueueItem<T> | null {\n    return this.removeMany([itemOrId], emitEvent)[0];\n  }\n\n  /**\n   * Removes multiple items from the queue based on the provided item or item IDs.\n   * @param itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.\n   * @param emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.\n   * @returns An array of removed QueueItem objects or null values.\n   */\n  public removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent = true): Array<QueueItem<T> | null> {\n    const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean) as QueueItem<T>[];\n    const removedItems = [];\n    for (const item of items) {\n      const itemRemoved = this.queue.delete(item.id.toString());\n      if (!itemRemoved) continue;\n      removedItems.push(item);\n    }\n    this.notify({ type: 'remove', items: removedItems }, emitEvent);\n\n    return items;\n  }\n\n  /**\n   * Clears the queue by removing all items.\n   *\n   * @param emitEvent - Whether to emit an event after clearing the queue. Default is true.\n   */\n  public clear(emitEvent = true): void {\n    const items = this.toArray();\n    this.queue.clear();\n    this.notify({ type: 'remove', items }, emitEvent);\n  }\n\n  /**\n   * Returns an array representation of the queue.\n   *\n   * @returns An array containing all the items in the queue.\n   */\n  public toArray(): QueueItem<T>[] {\n    return this.values;\n  }\n\n  private notify(event: QueueEvent<T>, emitEvent = true): void {\n    this.values = Array.from(this.queue, ([_, item]) => item).reverse();\n    this.firstItem = this.values[0] ?? null;\n    this.lastItem = this.values[this.values.length - 1] ?? null;\n    if (!emitEvent) return;\n    this.events$$.next(event);\n  }\n\n  private createEventObserver(type: QueueEventType): Observable<T> {\n    return this.events$$.pipe(\n      filter((event) => event.type === type),\n      map(({ items }) => items),\n      concatAll(),\n      share(),\n    );\n  }\n}\n"]}

package/esm2022/utils/lib/helpers/type-guards.mjs

@@ -1,29 +1,86 @@
 import { TemplateRef } from '@angular/core';
+/**
+ * Checks if the given value is a `ViewContainerRef`.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is ViewContainerRef} `true` if the value is a `ViewContainerRef`, otherwise `false`.
+ */
 export function isViewContainer(value) {
     return isFunction(value?.createComponent);
 }
+/**
+ * Checks if the given value is a `TemplateRef`.
+ *
+ * @template T - The embedded view type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is TemplateRef<T>} `true` if the value is a `TemplateRef`, otherwise `false`.
+ */
 export function isTemplateRef(value) {
     return value instanceof TemplateRef;
 }
+/**
+ * Checks if the given value is an Angular component class.
+ *
+ * @template T - The component class type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is Type<T>} `true` if the value is a component class, otherwise `false`.
+ */
 export function isComponent(value) {
     return isFunction(value);
 }
+/**
+ * Checks if the given value is a string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a string, otherwise `false`.
+ */
 export function isString(value) {
     return typeof value === 'string';
 }
+/**
+ * Checks if the given value is a non-empty string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a non-empty string, otherwise `false`.
+ */
 export function isNonEmptyString(value) {
     return isString(value) && value.length > 0;
 }
+/**
+ * Checks if the given value is a boolean.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is boolean} `true` if the value is a boolean, otherwise `false`.
+ */
 export function isBoolean(value) {
     return value === true || value === false;
 }
+/**
+ * Checks if the given value is a function.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is CallableFunction} `true` if the value is a function, otherwise `false`.
+ */
 export function isFunction(value) {
     return typeof value === 'function';
 }
+/**
+ * Checks if the given value is present (not null or undefined).
+ *
+ * @template T - The value type.
+ * @param {T | null | undefined} value - The value to check.
+ * @returns {value is NonNullable<T>} `true` if the value is present, otherwise `false`.
+ */
 export function isPresent(value) {
     return value !== null && value !== undefined;
 }
+/**
+ * Checks if the given value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is number} `true` if the value is a number, otherwise `false`.
+ */
 export function isNumber(value) {
     return typeof value === 'number';
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/until-destroyed.mjs

@@ -1,7 +1,45 @@
 import { DestroyRef, inject } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+/**
+ * Creates a MonoTypeOperatorFunction that automatically unsubscribes from observables when the host component or service is destroyed.
+ * It uses Angular's `DestroyRef` to detect when the component or service is destroyed and triggers the unsubscription at that point.
+ * This utility function helps in managing subscriptions and prevents memory leaks by ensuring observables are unsubscribed when no longer needed.
+ *
+ * @returns A function that returns a `MonoTypeOperatorFunction<T>`, which can be used in an RxJS pipe to automatically unsubscribe
+ * based on the component's or service's lifecycle.
+ *
+ * @example
+ * ```ts
+ * // In an Angular component or service
+ * import { Component } from '@angular/core';
+ * import { Observable } from 'rxjs';
+ * import { untilDestroyed } from './path/to/untilDestroyed';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: `<div>Example Component</div>`,
+ * })
+ * export class ExampleComponent {
+ *   private readonly takeUntilDestroyed = untilDestroyed();
+ *
+ *   constructor() {
+ *     const exampleObservable$ = new Observable(observer => {
+ *       // Observable logic here
+ *     });
+ *
+ *     exampleObservable$.pipe(
+ *       this.takeUntilDestroyed(),
+ *     ).subscribe(data => {
+ *       // Subscription logic here
+ *     });
+ *   }
+ *
+ *   // No need to manually implement ngOnDestroy to unsubscribe
+ * }
+ * ```
+ */
 export function untilDestroyed() {
     const destroyRef = inject(DestroyRef);
     return () => takeUntilDestroyed(destroyRef);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW50aWwtZGVzdHJveWVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy91bnRpbC1kZXN0cm95ZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHaEUsTUFBTSxVQUFVLGNBQWM7SUFDNUIsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRXRDLE9BQU8sR0FBRyxFQUFFLENBQUMsa0JBQWtCLENBQUMsVUFBVSxDQUFDLENBQUM7QUFDOUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERlc3Ryb3lSZWYsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgdGFrZVVudGlsRGVzdHJveWVkIH0gZnJvbSAnQGFuZ3VsYXIvY29yZS9yeGpzLWludGVyb3AnO1xuaW1wb3J0IHsgTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBmdW5jdGlvbiB1bnRpbERlc3Ryb3llZCgpOiA8VD4oKSA9PiBNb25vVHlwZU9wZXJhdG9yRnVuY3Rpb248VD4ge1xuICBjb25zdCBkZXN0cm95UmVmID0gaW5qZWN0KERlc3Ryb3lSZWYpO1xuXG4gIHJldHVybiAoKSA9PiB0YWtlVW50aWxEZXN0cm95ZWQoZGVzdHJveVJlZik7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/odx-angular-animations.mjs

@@ -8,21 +8,135 @@ const DEFAULT_ANIMATION_PARAMS = {
     delay: '0ms',
 };
 
+/**
+ * Animation for smoothly expanding an element from height 0 to its natural height.
+ * It transitions the element's height, padding, margin, and opacity from a collapsed state to an expanded state,
+ * making the element smoothly grow into view.
+ *
+ * The `expand` animation uses `DEFAULT_ANIMATION_PARAMS` for its default parameters, which can be overridden
+ * when using the animation.
+ *
+ * @example
+ * ```ts
+ * // Example usage in an Angular component
+ * import { expand, collapse } from '@odx/angular/animations';
+ *
+ * @Component({
+ *   selector: 'my-expandable-component',
+ *   templateUrl: './expandable-component.html',
+ *   animations: [
+ *     trigger('expandCollapse', [
+ *       transition('collapsed => expanded', useAnimation(expand)),
+ *       transition('expanded => collapsed', useAnimation(collapse)),
+ *     ])
+ *   ]
+ * })
+ * export class ExpandableComponent {
+ *   state = 'collapsed';
+ *
+ *   toggle(): void {
+ *     this.state = this.state === 'collapsed' ? 'expanded' : 'collapsed';
+ *   }
+ * }
+ * ```
+ *
+ * The animation smoothly transitions various properties (height, padding, margin, and opacity) and is controlled
+ * through parameters defined in `DEFAULT_ANIMATION_PARAMS` or those provided during usage.
+ */
 const expand = animation([
     style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' }),
     animate('{{duration}} {{ delay }} {{ timingFn }}', style({ height: '*', paddingTop: '*', paddingBottom: '*', opacity: 1, marginTop: '*', marginBottom: '*' })),
 ], {
     params: DEFAULT_ANIMATION_PARAMS,
 });
+/**
+ * Animation for smoothly collapsing an element from its natural height to height 0.
+ * It transitions the element's height, padding, margin, and opacity from an expanded state to a collapsed state,
+ * making the element smoothly shrink out of view.
+ *
+ * The `collapse` animation also uses `DEFAULT_ANIMATION_PARAMS` for its default parameters, which can be overridden
+ * when using the animation. It's designed to be used in conjunction with the `expand` animation for creating
+ * expandable/collapsible elements.
+ */
 const collapse = animation([
     animate('{{duration}} {{ delay }} {{ timingFn }}', style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' })),
 ], {
     params: DEFAULT_ANIMATION_PARAMS,
 });
 
+/**
+ * Generates a fadeIn animation with customizable opacity target.
+ * This animation gradually changes the element's opacity from 0 to a specified value, creating a "fade in" visual effect.
+ *
+ * @param {number} to - The final opacity value of the element at the end of the animation. Defaults to 1 (fully opaque).
+ * @returns {AnimationReferenceMetadata} An Angular animation object that can be used with Angular's animation system.
+ *
+ * @example
+ * ```ts
+ * // Example usage in an Angular component with a fadeIn animation
+ * import { fadeIn } from '@odx/angular/animations';
+ * import { trigger, transition, useAnimation } from '@angular/animations';
+ *
+ * @Component({
+ *   selector: 'app-fade-in-example',
+ *   template: `
+ *       <div @fadeInAnimation *ngIf="isVisible">Fade In Content</div>
+ *       <button (click)="showContent()">Show Content</button>`,
+ *   animations: [
+ *     trigger('fadeInAnimation', [
+ *       transition(':enter', useAnimation(fadeIn(), { params: { duration: '500ms' } }))
+ *     ])
+ *   ]
+ * })
+ * export class FadeInExampleComponent {
+ *   isVisible = false;
+ *
+ *   showContent(): void {
+ *     this.isVisible = true;
+ *   }
+ * }
+ * ```
+ *
+ * This example demonstrates how to apply the fadeIn animation to an element, making it smoothly appear on the screen.
+ */
 const fadeIn = (to = 1) => animation([style({ opacity: 0 }), animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {
     params: DEFAULT_ANIMATION_PARAMS,
 });
+/**
+ * Generates a fadeOut animation with customizable opacity target.
+ * This animation gradually changes the element's opacity from its current value to a specified value, creating a "fade out" visual effect.
+ *
+ * @param {number} to - The target opacity value of the element at the end of the animation. Defaults to 0 (fully transparent).
+ * @returns {AnimationReferenceMetadata} An Angular animation object that can be used with Angular's animation system.
+ *
+ * @example
+ * ```ts
+ * // Example usage in an Angular component with a fadeOut animation
+ * import { fadeOut } from '@odx/angular/animations';
+ * import { trigger, transition, useAnimation } from '@angular/animations';
+ *
+ * @Component({
+ *   selector: 'app-fade-out-example',
+ *   template: `
+ *      <div @fadeOutAnimation *ngIf="isVisible">Fade Out Content</div>
+ *      <button (click)="hideContent()">Hide Content</button>`,
+ *   animations: [
+ *     trigger('fadeOutAnimation', [
+ *       transition(':leave', useAnimation(fadeOut(), { params: { duration: '500ms' } }))
+ *     ])
+ *   ]
+ * })
+ * export class FadeOutExampleComponent {
+ *   isVisible = true;
+ *
+ *   hideContent(): void {
+ *     this.isVisible = false;
+ *   }
+ * }
+ * ```
+ *
+ * This example demonstrates how to apply the fadeOut animation to an element, making it smoothly disappear from the screen.
+ */
 const fadeOut = (to = 0) => animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {
     params: DEFAULT_ANIMATION_PARAMS,
 });
@@ -46,6 +160,27 @@ function createSlideOutAnimation(to, direction) {
         },
     });
 }
+/**
+ * Utility functions for creating slide-in and slide-out animations in specific directions.
+ * These include slideInX, slideInY, slideInDown, slideInUp, slideInLeft, slideInRight,
+ * slideOutX, slideOutY, slideOutDown, slideOutUp, slideOutLeft, and slideOutRight.
+ * Each function is configured for a specific slide direction and distance, making it easy to apply
+ * consistent slide animations across your application.
+ *
+ * @example
+ * ```ts
+ * // Using slideInLeft and slideOutRight in a component
+ * animations: [
+ *   trigger('slideInOut', [
+ *     transition(':enter', [useAnimation(slideInLeft)]),
+ *     transition(':leave', [useAnimation(slideOutRight)])
+ *   ])
+ * ]
+ * ```
+ *
+ * Note: The 'from' and 'to' parameters for slideIn and slideOut functions respectively
+ * can be customized for different slide distances.
+ */
 const slideInX = (from) => createSlideInAnimation(from, 'X');
 const slideInY = (from) => createSlideInAnimation(from, 'Y');
 const slideInDown = slideInY('-100%');
@@ -59,6 +194,44 @@ const slideOutUp = slideOutY('-100%');
 const slideOutLeft = slideOutX('-100%');
 const slideOutRight = slideOutX('100%');
 
+/**
+ * Utility animation that waits for animations on child components to complete.
+ * This animation should be used within parent components that have child components with their
+ * own animations. It ensures that the parent's enter and leave animations are only triggered
+ * after all child animations have completed, creating a seamless animation sequence.
+ *
+ * This utility uses Angular's animation functions `query` and `animateChild` to find and animate
+ * child elements marked with Angular's animation triggers. The `{ optional: true }` parameter
+ * ensures that the animation gracefully handles cases where no child animations are defined.
+ *
+ * @example
+ * ```ts
+ * // Using waitForChildAnimations in a parent component with children that have animations
+ * import { trigger, transition, style, animate, query, animateChild } from '@angular/animations';
+ * import { waitForChildAnimations } from '@odx/angular/animations';
+ *
+ * @Component({
+ *   selector: 'app-parent',
+ *   templateUrl: './parent.component.html',
+ *   animations: [
+ *     trigger('parentAnimation', [
+ *       // Define parent animations here
+ *       transition(':enter', [style({ opacity: 0 }), animate('0.5s ease-in', style({ opacity: 1 }))]),
+ *       transition(':leave', [animate('0.5s ease-out', style({ opacity: 0 }))]),
+ *       // Use waitForChildAnimations for coordinating with child animations
+ *       waitForChildAnimations
+ *     ])
+ *   ]
+ * })
+ * export class ParentComponent {
+ *   // Component logic here
+ * }
+ * ```
+ *
+ * Note: The `waitForChildAnimations` utility is added to the parent component's animation triggers,
+ * ensuring that any child component animations are completed before continuing with the parent's
+ * own animations.
+ */
 const waitForChildAnimations = transition(':enter, :leave', [query('@*', animateChild(), { optional: true })]);
 
 /**

package/fesm2022/odx-angular-animations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"odx-angular-animations.mjs","sources":["../../../../libs/angular/animations/src/lib/config.ts","../../../../libs/angular/animations/src/lib/expand.ts","../../../../libs/angular/animations/src/lib/fade.ts","../../../../libs/angular/animations/src/lib/slide.ts","../../../../libs/angular/animations/src/lib/wait-for-child-animations.ts","../../../../libs/angular/animations/src/odx-angular-animations.ts"],"sourcesContent":["export const DEFAULT_ANIMATION_TIMING_FN = 'ease';\nexport const DEFAULT_ANIMATION_DURATION = '250ms';\nexport const DEFAULT_ANIMATION_PARAMS = {\n  timingFn: DEFAULT_ANIMATION_TIMING_FN,\n  duration: DEFAULT_ANIMATION_DURATION,\n  delay: '0ms',\n};\n","import { animate, animation, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\nexport const expand = animation(\n  [\n    style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' }),\n    animate(\n      '{{duration}} {{ delay }} {{ timingFn }}',\n      style({ height: '*', paddingTop: '*', paddingBottom: '*', opacity: 1, marginTop: '*', marginBottom: '*' })\n    ),\n  ],\n  {\n    params: DEFAULT_ANIMATION_PARAMS,\n  }\n);\n\nexport const collapse = animation(\n  [\n    animate(\n      '{{duration}} {{ delay }} {{ timingFn }}',\n      style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' })\n    ),\n  ],\n  {\n    params: DEFAULT_ANIMATION_PARAMS,\n  }\n);\n","import { animate, animation, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\nexport const fadeIn = (to = 1) =>\n  animation([style({ opacity: 0 }), animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {\n    params: DEFAULT_ANIMATION_PARAMS,\n  });\n\nexport const fadeOut = (to = 0) =>\n  animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {\n    params: DEFAULT_ANIMATION_PARAMS,\n  });\n","import { animate, animation, AnimationReferenceMetadata, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\nfunction createSlideInAnimation(from: string, direction: 'X' | 'Y'): AnimationReferenceMetadata {\n  return animation(\n    [\n      style({ transform: `translate${direction}({{ from }})` }),\n      animate('{{duration}} {{ delay }} {{ timingFn }}', style({ transform: `translate${direction}(0)` })),\n    ],\n    {\n      params: {\n        ...DEFAULT_ANIMATION_PARAMS,\n        from,\n      },\n    }\n  );\n}\n\nfunction createSlideOutAnimation(to: string, direction: 'X' | 'Y'): AnimationReferenceMetadata {\n  return animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ transform: `translate${direction}({{ to }})` }))], {\n    params: {\n      ...DEFAULT_ANIMATION_PARAMS,\n      to,\n    },\n  });\n}\n\nexport const slideInX = (from: string) => createSlideInAnimation(from, 'X');\nexport const slideInY = (from: string) => createSlideInAnimation(from, 'Y');\nexport const slideInDown = slideInY('-100%');\nexport const slideInUp = slideInY('100%');\nexport const slideInLeft = slideInX('-100%');\nexport const slideInRight = slideInX('100%');\n\nexport const slideOutX = (to: string) => createSlideOutAnimation(to, 'X');\nexport const slideOutY = (to: string) => createSlideOutAnimation(to, 'Y');\nexport const slideOutDown = slideOutY('100%');\nexport const slideOutUp = slideOutY('-100%');\nexport const slideOutLeft = slideOutX('-100%');\nexport const slideOutRight = slideOutX('100%');\n","import { animateChild, query, transition } from '@angular/animations';\n\nexport const waitForChildAnimations = transition(':enter, :leave', [query('@*', animateChild(), { optional: true })]);\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAAO,MAAM,2BAA2B,GAAG,MAAM,CAAC;AAC3C,MAAM,0BAA0B,GAAG,OAAO,CAAC;AAC3C,MAAM,wBAAwB,GAAG;AACtC,IAAA,QAAQ,EAAE,2BAA2B;AACrC,IAAA,QAAQ,EAAE,0BAA0B;AACpC,IAAA,KAAK,EAAE,KAAK;CACb;;ACHM,MAAM,MAAM,GAAG,SAAS,CAC7B;AACE,IAAA,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAClI,IAAA,OAAO,CACL,yCAAyC,EACzC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAC3G;CACF,EACD;AACE,IAAA,MAAM,EAAE,wBAAwB;AACjC,CAAA,EACD;AAEK,MAAM,QAAQ,GAAG,SAAS,CAC/B;AACE,IAAA,OAAO,CACL,yCAAyC,EACzC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CACnI;CACF,EACD;AACE,IAAA,MAAM,EAAE,wBAAwB;AACjC,CAAA;;ACtBU,MAAA,MAAM,GAAG,CAAC,EAAE,GAAG,CAAC,KAC3B,SAAS,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,yCAAyC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE;AAC7G,IAAA,MAAM,EAAE,wBAAwB;AACjC,CAAA,EAAE;AAEE,MAAM,OAAO,GAAG,CAAC,EAAE,GAAG,CAAC,KAC5B,SAAS,CAAC,CAAC,OAAO,CAAC,yCAAyC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE;AACtF,IAAA,MAAM,EAAE,wBAAwB;AACjC,CAAA;;ACRH,SAAS,sBAAsB,CAAC,IAAY,EAAE,SAAoB,EAAA;AAChE,IAAA,OAAO,SAAS,CACd;QACE,KAAK,CAAC,EAAE,SAAS,EAAE,YAAY,SAAS,CAAA,YAAA,CAAc,EAAE,CAAC;AACzD,QAAA,OAAO,CAAC,yCAAyC,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,CAAY,SAAA,EAAA,SAAS,CAAK,GAAA,CAAA,EAAE,CAAC,CAAC;KACrG,EACD;AACE,QAAA,MAAM,EAAE;AACN,YAAA,GAAG,wBAAwB;YAC3B,IAAI;AACL,SAAA;AACF,KAAA,CACF,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAAC,EAAU,EAAE,SAAoB,EAAA;AAC/D,IAAA,OAAO,SAAS,CAAC,CAAC,OAAO,CAAC,yCAAyC,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,YAAY,SAAS,CAAA,UAAA,CAAY,EAAE,CAAC,CAAC,CAAC,EAAE;AAC9H,QAAA,MAAM,EAAE;AACN,YAAA,GAAG,wBAAwB;YAC3B,EAAE;AACH,SAAA;AACF,KAAA,CAAC,CAAC;AACL,CAAC;AAEM,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAK,sBAAsB,CAAC,IAAI,EAAE,GAAG,EAAE;AACrE,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAK,sBAAsB,CAAC,IAAI,EAAE,GAAG,EAAE;MAC/D,WAAW,GAAG,QAAQ,CAAC,OAAO,EAAE;MAChC,SAAS,GAAG,QAAQ,CAAC,MAAM,EAAE;MAC7B,WAAW,GAAG,QAAQ,CAAC,OAAO,EAAE;MAChC,YAAY,GAAG,QAAQ,CAAC,MAAM,EAAE;AAEtC,MAAM,SAAS,GAAG,CAAC,EAAU,KAAK,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE;AACnE,MAAM,SAAS,GAAG,CAAC,EAAU,KAAK,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE;MAC7D,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE;MACjC,UAAU,GAAG,SAAS,CAAC,OAAO,EAAE;MAChC,YAAY,GAAG,SAAS,CAAC,OAAO,EAAE;MAClC,aAAa,GAAG,SAAS,CAAC,MAAM;;ACrChC,MAAA,sBAAsB,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;;ACFpH;;AAEG;;;;"}
+{"version":3,"file":"odx-angular-animations.mjs","sources":["../../../../libs/angular/animations/src/lib/config.ts","../../../../libs/angular/animations/src/lib/expand.ts","../../../../libs/angular/animations/src/lib/fade.ts","../../../../libs/angular/animations/src/lib/slide.ts","../../../../libs/angular/animations/src/lib/wait-for-child-animations.ts","../../../../libs/angular/animations/src/odx-angular-animations.ts"],"sourcesContent":["export const DEFAULT_ANIMATION_TIMING_FN = 'ease';\nexport const DEFAULT_ANIMATION_DURATION = '250ms';\nexport const DEFAULT_ANIMATION_PARAMS = {\n  timingFn: DEFAULT_ANIMATION_TIMING_FN,\n  duration: DEFAULT_ANIMATION_DURATION,\n  delay: '0ms',\n};\n","import { animate, animation, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\n/**\n * Animation for smoothly expanding an element from height 0 to its natural height.\n * It transitions the element's height, padding, margin, and opacity from a collapsed state to an expanded state,\n * making the element smoothly grow into view.\n *\n * The `expand` animation uses `DEFAULT_ANIMATION_PARAMS` for its default parameters, which can be overridden\n * when using the animation.\n *\n * @example\n * ```ts\n * // Example usage in an Angular component\n * import { expand, collapse } from '@odx/angular/animations';\n *\n * @Component({\n *   selector: 'my-expandable-component',\n *   templateUrl: './expandable-component.html',\n *   animations: [\n *     trigger('expandCollapse', [\n *       transition('collapsed => expanded', useAnimation(expand)),\n *       transition('expanded => collapsed', useAnimation(collapse)),\n *     ])\n *   ]\n * })\n * export class ExpandableComponent {\n *   state = 'collapsed';\n *\n *   toggle(): void {\n *     this.state = this.state === 'collapsed' ? 'expanded' : 'collapsed';\n *   }\n * }\n * ```\n *\n * The animation smoothly transitions various properties (height, padding, margin, and opacity) and is controlled\n * through parameters defined in `DEFAULT_ANIMATION_PARAMS` or those provided during usage.\n */\nexport const expand = animation(\n  [\n    style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' }),\n    animate(\n      '{{duration}} {{ delay }} {{ timingFn }}',\n      style({ height: '*', paddingTop: '*', paddingBottom: '*', opacity: 1, marginTop: '*', marginBottom: '*' }),\n    ),\n  ],\n  {\n    params: DEFAULT_ANIMATION_PARAMS,\n  },\n);\n\n/**\n * Animation for smoothly collapsing an element from its natural height to height 0.\n * It transitions the element's height, padding, margin, and opacity from an expanded state to a collapsed state,\n * making the element smoothly shrink out of view.\n *\n * The `collapse` animation also uses `DEFAULT_ANIMATION_PARAMS` for its default parameters, which can be overridden\n * when using the animation. It's designed to be used in conjunction with the `expand` animation for creating\n * expandable/collapsible elements.\n */\nexport const collapse = animation(\n  [\n    animate(\n      '{{duration}} {{ delay }} {{ timingFn }}',\n      style({ height: 0, minHeight: 0, paddingTop: 0, paddingBottom: 0, opacity: 0, marginTop: 0, marginBottom: 0, overflow: 'hidden' }),\n    ),\n  ],\n  {\n    params: DEFAULT_ANIMATION_PARAMS,\n  },\n);\n","import { animate, animation, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\n/**\n * Generates a fadeIn animation with customizable opacity target.\n * This animation gradually changes the element's opacity from 0 to a specified value, creating a \"fade in\" visual effect.\n *\n * @param {number} to - The final opacity value of the element at the end of the animation. Defaults to 1 (fully opaque).\n * @returns {AnimationReferenceMetadata} An Angular animation object that can be used with Angular's animation system.\n *\n * @example\n * ```ts\n * // Example usage in an Angular component with a fadeIn animation\n * import { fadeIn } from '@odx/angular/animations';\n * import { trigger, transition, useAnimation } from '@angular/animations';\n *\n * @Component({\n *   selector: 'app-fade-in-example',\n *   template: `\n *       <div @fadeInAnimation *ngIf=\"isVisible\">Fade In Content</div>\n *       <button (click)=\"showContent()\">Show Content</button>`,\n *   animations: [\n *     trigger('fadeInAnimation', [\n *       transition(':enter', useAnimation(fadeIn(), { params: { duration: '500ms' } }))\n *     ])\n *   ]\n * })\n * export class FadeInExampleComponent {\n *   isVisible = false;\n *\n *   showContent(): void {\n *     this.isVisible = true;\n *   }\n * }\n * ```\n *\n * This example demonstrates how to apply the fadeIn animation to an element, making it smoothly appear on the screen.\n */\nexport const fadeIn = (to = 1) =>\n  animation([style({ opacity: 0 }), animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {\n    params: DEFAULT_ANIMATION_PARAMS,\n  });\n\n/**\n * Generates a fadeOut animation with customizable opacity target.\n * This animation gradually changes the element's opacity from its current value to a specified value, creating a \"fade out\" visual effect.\n *\n * @param {number} to - The target opacity value of the element at the end of the animation. Defaults to 0 (fully transparent).\n * @returns {AnimationReferenceMetadata} An Angular animation object that can be used with Angular's animation system.\n *\n * @example\n * ```ts\n * // Example usage in an Angular component with a fadeOut animation\n * import { fadeOut } from '@odx/angular/animations';\n * import { trigger, transition, useAnimation } from '@angular/animations';\n *\n * @Component({\n *   selector: 'app-fade-out-example',\n *   template: `\n *      <div @fadeOutAnimation *ngIf=\"isVisible\">Fade Out Content</div>\n *      <button (click)=\"hideContent()\">Hide Content</button>`,\n *   animations: [\n *     trigger('fadeOutAnimation', [\n *       transition(':leave', useAnimation(fadeOut(), { params: { duration: '500ms' } }))\n *     ])\n *   ]\n * })\n * export class FadeOutExampleComponent {\n *   isVisible = true;\n *\n *   hideContent(): void {\n *     this.isVisible = false;\n *   }\n * }\n * ```\n *\n * This example demonstrates how to apply the fadeOut animation to an element, making it smoothly disappear from the screen.\n */\nexport const fadeOut = (to = 0) =>\n  animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {\n    params: DEFAULT_ANIMATION_PARAMS,\n  });\n","import { animate, animation, AnimationReferenceMetadata, style } from '@angular/animations';\nimport { DEFAULT_ANIMATION_PARAMS } from './config';\n\nfunction createSlideInAnimation(from: string, direction: 'X' | 'Y'): AnimationReferenceMetadata {\n  return animation(\n    [\n      style({ transform: `translate${direction}({{ from }})` }),\n      animate('{{duration}} {{ delay }} {{ timingFn }}', style({ transform: `translate${direction}(0)` })),\n    ],\n    {\n      params: {\n        ...DEFAULT_ANIMATION_PARAMS,\n        from,\n      },\n    },\n  );\n}\n\nfunction createSlideOutAnimation(to: string, direction: 'X' | 'Y'): AnimationReferenceMetadata {\n  return animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ transform: `translate${direction}({{ to }})` }))], {\n    params: {\n      ...DEFAULT_ANIMATION_PARAMS,\n      to,\n    },\n  });\n}\n\n/**\n * Utility functions for creating slide-in and slide-out animations in specific directions.\n * These include slideInX, slideInY, slideInDown, slideInUp, slideInLeft, slideInRight,\n * slideOutX, slideOutY, slideOutDown, slideOutUp, slideOutLeft, and slideOutRight.\n * Each function is configured for a specific slide direction and distance, making it easy to apply\n * consistent slide animations across your application.\n *\n * @example\n * ```ts\n * // Using slideInLeft and slideOutRight in a component\n * animations: [\n *   trigger('slideInOut', [\n *     transition(':enter', [useAnimation(slideInLeft)]),\n *     transition(':leave', [useAnimation(slideOutRight)])\n *   ])\n * ]\n * ```\n *\n * Note: The 'from' and 'to' parameters for slideIn and slideOut functions respectively\n * can be customized for different slide distances.\n */\nexport const slideInX = (from: string) => createSlideInAnimation(from, 'X');\nexport const slideInY = (from: string) => createSlideInAnimation(from, 'Y');\nexport const slideInDown = slideInY('-100%');\nexport const slideInUp = slideInY('100%');\nexport const slideInLeft = slideInX('-100%');\nexport const slideInRight = slideInX('100%');\n\nexport const slideOutX = (to: string) => createSlideOutAnimation(to, 'X');\nexport const slideOutY = (to: string) => createSlideOutAnimation(to, 'Y');\nexport const slideOutDown = slideOutY('100%');\nexport const slideOutUp = slideOutY('-100%');\nexport const slideOutLeft = slideOutX('-100%');\nexport const slideOutRight = slideOutX('100%');\n","import { animateChild, query, transition } from '@angular/animations';\n\n/**\n * Utility animation that waits for animations on child components to complete.\n * This animation should be used within parent components that have child components with their\n * own animations. It ensures that the parent's enter and leave animations are only triggered\n * after all child animations have completed, creating a seamless animation sequence.\n *\n * This utility uses Angular's animation functions `query` and `animateChild` to find and animate\n * child elements marked with Angular's animation triggers. The `{ optional: true }` parameter\n * ensures that the animation gracefully handles cases where no child animations are defined.\n *\n * @example\n * ```ts\n * // Using waitForChildAnimations in a parent component with children that have animations\n * import { trigger, transition, style, animate, query, animateChild } from '@angular/animations';\n * import { waitForChildAnimations } from '@odx/angular/animations';\n *\n * @Component({\n *   selector: 'app-parent',\n *   templateUrl: './parent.component.html',\n *   animations: [\n *     trigger('parentAnimation', [\n *       // Define parent animations here\n *       transition(':enter', [style({ opacity: 0 }), animate('0.5s ease-in', style({ opacity: 1 }))]),\n *       transition(':leave', [animate('0.5s ease-out', style({ opacity: 0 }))]),\n *       // Use waitForChildAnimations for coordinating with child animations\n *       waitForChildAnimations\n *     ])\n *   ]\n * })\n * export class ParentComponent {\n *   // Component logic here\n * }\n * ```\n *\n * Note: The `waitForChildAnimations` utility is added to the parent component's animation triggers,\n * ensuring that any child component animations are completed before continuing with the parent's\n * own animations.\n */\nexport const waitForChildAnimations = transition(':enter, :leave', [query('@*', animateChild(), { optional: true })]);\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}