@odx/angular 5.7.4 → 6.0.1

package/components/wizard/lib/wizard.component.d.ts

@@ -1,6 +1,11 @@
 import { AfterViewInit, EventEmitter, QueryList } from '@angular/core';
 import { WizardStepComponent } from './components';
 import * as i0 from "@angular/core";
+/**
+ * WizardComponent manages a series of steps, providing functionality for navigating forwards and backwards
+ * through the steps. It dynamically adjusts the visibility of steps based on the available space and current active step.
+ * The component supports both horizontal and vertical orientations.
+ */
 export declare class WizardComponent implements AfterViewInit {
     private readonly destroyed;
     private readonly renderer;
@@ -11,11 +16,26 @@ export declare class WizardComponent implements AfterViewInit {
     private activeStep;
     protected readonly steps: QueryList<WizardStepComponent>;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates if the wizard layout should be vertical. When true, the wizard orientation changes to vertical.
+     */
     vertical: boolean;
+    /**
+     * Event emitted when the active step changes, providing the index of the new active step.
+     */
     activeStepChanged: EventEmitter<number>;
     ngAfterViewInit(): void;
+    /**
+     * Navigates to the next step in the wizard.
+     */
     nextStep(): void;
+    /**
+     * Navigates to the previous step in the wizard.
+     */
     previousStep(): void;
+    /**
+     * Sets the active step to the specified index.
+     */
     setActiveStepValid(): void;
     private calculateVisibleStepsSegments;
     private getStyleFromCSS;

package/esm2022/animations/lib/expand.mjs

@@ -1,14 +1,58 @@
 import { animate, animation, style } from '@angular/animations';
 import { DEFAULT_ANIMATION_PARAMS } from './config';
+/**
+ * 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.
+ */
 export 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.
+ */
 export 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,
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/animations/lib/fade.mjs

@@ -1,9 +1,79 @@
 import { animate, animation, style } from '@angular/animations';
 import { DEFAULT_ANIMATION_PARAMS } from './config';
+/**
+ * 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.
+ */
 export 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.
+ */
 export const fadeOut = (to = 0) => animation([animate('{{duration}} {{ delay }} {{ timingFn }}', style({ opacity: to }))], {
     params: DEFAULT_ANIMATION_PARAMS,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9hbmltYXRpb25zL3NyYy9saWIvZmFkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLENBQUMsRUFBRSxHQUFHLENBQUMsRUFBRSxFQUFFLENBQy9CLFNBQVMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE9BQU8sQ0FBQyx5Q0FBeUMsRUFBRSxLQUFLLENBQUMsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUU7SUFDN0csTUFBTSxFQUFFLHdCQUF3QjtDQUNqQyxDQUFDLENBQUM7QUFFTCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxFQUFFLEVBQUUsQ0FDaEMsU0FBUyxDQUFDLENBQUMsT0FBTyxDQUFDLHlDQUF5QyxFQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRTtJQUN0RixNQUFNLEVBQUUsd0JBQXdCO0NBQ2pDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGFuaW1hdGUsIGFuaW1hdGlvbiwgc3R5bGUgfSBmcm9tICdAYW5ndWxhci9hbmltYXRpb25zJztcbmltcG9ydCB7IERFRkFVTFRfQU5JTUFUSU9OX1BBUkFNUyB9IGZyb20gJy4vY29uZmlnJztcblxuZXhwb3J0IGNvbnN0IGZhZGVJbiA9ICh0byA9IDEpID0+XG4gIGFuaW1hdGlvbihbc3R5bGUoeyBvcGFjaXR5OiAwIH0pLCBhbmltYXRlKCd7e2R1cmF0aW9ufX0ge3sgZGVsYXkgfX0ge3sgdGltaW5nRm4gfX0nLCBzdHlsZSh7IG9wYWNpdHk6IHRvIH0pKV0sIHtcbiAgICBwYXJhbXM6IERFRkFVTFRfQU5JTUFUSU9OX1BBUkFNUyxcbiAgfSk7XG5cbmV4cG9ydCBjb25zdCBmYWRlT3V0ID0gKHRvID0gMCkgPT5cbiAgYW5pbWF0aW9uKFthbmltYXRlKCd7e2R1cmF0aW9ufX0ge3sgZGVsYXkgfX0ge3sgdGltaW5nRm4gfX0nLCBzdHlsZSh7IG9wYWNpdHk6IHRvIH0pKV0sIHtcbiAgICBwYXJhbXM6IERFRkFVTFRfQU5JTUFUSU9OX1BBUkFNUyxcbiAgfSk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/animations/lib/slide.mjs

@@ -19,6 +19,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.
+ */
 export const slideInX = (from) => createSlideInAnimation(from, 'X');
 export const slideInY = (from) => createSlideInAnimation(from, 'Y');
 export const slideInDown = slideInY('-100%');
@@ -31,4 +52,4 @@ export const slideOutDown = slideOutY('100%');
 export const slideOutUp = slideOutY('-100%');
 export const slideOutLeft = slideOutX('-100%');
 export const slideOutRight = slideOutX('100%');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvYW5pbWF0aW9ucy9zcmMvbGliL3NsaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUE4QixLQUFLLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFcEQsU0FBUyxzQkFBc0IsQ0FBQyxJQUFZLEVBQUUsU0FBb0I7SUFDaEUsT0FBTyxTQUFTLENBQ2Q7UUFDRSxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsWUFBWSxTQUFTLGNBQWMsRUFBRSxDQUFDO1FBQ3pELE9BQU8sQ0FBQyx5Q0FBeUMsRUFBRSxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsWUFBWSxTQUFTLEtBQUssRUFBRSxDQUFDLENBQUM7S0FDckcsRUFDRDtRQUNFLE1BQU0sRUFBRTtZQUNOLEdBQUcsd0JBQXdCO1lBQzNCLElBQUk7U0FDTDtLQUNGLENBQ0YsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLHVCQUF1QixDQUFDLEVBQVUsRUFBRSxTQUFvQjtJQUMvRCxPQUFPLFNBQVMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyx5Q0FBeUMsRUFBRSxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsWUFBWSxTQUFTLFlBQVksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFO1FBQzlILE1BQU0sRUFBRTtZQUNOLEdBQUcsd0JBQXdCO1lBQzNCLEVBQUU7U0FDSDtLQUNGLENBQUMsQ0FBQztBQUNMLENBQUM7QUFFRCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLHNCQUFzQixDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztBQUM1RSxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLHNCQUFzQixDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztBQUM1RSxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQzdDLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDMUMsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUM3QyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBRTdDLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLEVBQVUsRUFBRSxFQUFFLENBQUMsdUJBQXVCLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0FBQzFFLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLEVBQVUsRUFBRSxFQUFFLENBQUMsdUJBQXVCLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0FBQzFFLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDOUMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUM3QyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQy9DLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhbmltYXRlLCBhbmltYXRpb24sIEFuaW1hdGlvblJlZmVyZW5jZU1ldGFkYXRhLCBzdHlsZSB9IGZyb20gJ0Bhbmd1bGFyL2FuaW1hdGlvbnMnO1xuaW1wb3J0IHsgREVGQVVMVF9BTklNQVRJT05fUEFSQU1TIH0gZnJvbSAnLi9jb25maWcnO1xuXG5mdW5jdGlvbiBjcmVhdGVTbGlkZUluQW5pbWF0aW9uKGZyb206IHN0cmluZywgZGlyZWN0aW9uOiAnWCcgfCAnWScpOiBBbmltYXRpb25SZWZlcmVuY2VNZXRhZGF0YSB7XG4gIHJldHVybiBhbmltYXRpb24oXG4gICAgW1xuICAgICAgc3R5bGUoeyB0cmFuc2Zvcm06IGB0cmFuc2xhdGUke2RpcmVjdGlvbn0oe3sgZnJvbSB9fSlgIH0pLFxuICAgICAgYW5pbWF0ZSgne3tkdXJhdGlvbn19IHt7IGRlbGF5IH19IHt7IHRpbWluZ0ZuIH19Jywgc3R5bGUoeyB0cmFuc2Zvcm06IGB0cmFuc2xhdGUke2RpcmVjdGlvbn0oMClgIH0pKSxcbiAgICBdLFxuICAgIHtcbiAgICAgIHBhcmFtczoge1xuICAgICAgICAuLi5ERUZBVUxUX0FOSU1BVElPTl9QQVJBTVMsXG4gICAgICAgIGZyb20sXG4gICAgICB9LFxuICAgIH1cbiAgKTtcbn1cblxuZnVuY3Rpb24gY3JlYXRlU2xpZGVPdXRBbmltYXRpb24odG86IHN0cmluZywgZGlyZWN0aW9uOiAnWCcgfCAnWScpOiBBbmltYXRpb25SZWZlcmVuY2VNZXRhZGF0YSB7XG4gIHJldHVybiBhbmltYXRpb24oW2FuaW1hdGUoJ3t7ZHVyYXRpb259fSB7eyBkZWxheSB9fSB7eyB0aW1pbmdGbiB9fScsIHN0eWxlKHsgdHJhbnNmb3JtOiBgdHJhbnNsYXRlJHtkaXJlY3Rpb259KHt7IHRvIH19KWAgfSkpXSwge1xuICAgIHBhcmFtczoge1xuICAgICAgLi4uREVGQVVMVF9BTklNQVRJT05fUEFSQU1TLFxuICAgICAgdG8sXG4gICAgfSxcbiAgfSk7XG59XG5cbmV4cG9ydCBjb25zdCBzbGlkZUluWCA9IChmcm9tOiBzdHJpbmcpID0+IGNyZWF0ZVNsaWRlSW5BbmltYXRpb24oZnJvbSwgJ1gnKTtcbmV4cG9ydCBjb25zdCBzbGlkZUluWSA9IChmcm9tOiBzdHJpbmcpID0+IGNyZWF0ZVNsaWRlSW5BbmltYXRpb24oZnJvbSwgJ1knKTtcbmV4cG9ydCBjb25zdCBzbGlkZUluRG93biA9IHNsaWRlSW5ZKCctMTAwJScpO1xuZXhwb3J0IGNvbnN0IHNsaWRlSW5VcCA9IHNsaWRlSW5ZKCcxMDAlJyk7XG5leHBvcnQgY29uc3Qgc2xpZGVJbkxlZnQgPSBzbGlkZUluWCgnLTEwMCUnKTtcbmV4cG9ydCBjb25zdCBzbGlkZUluUmlnaHQgPSBzbGlkZUluWCgnMTAwJScpO1xuXG5leHBvcnQgY29uc3Qgc2xpZGVPdXRYID0gKHRvOiBzdHJpbmcpID0+IGNyZWF0ZVNsaWRlT3V0QW5pbWF0aW9uKHRvLCAnWCcpO1xuZXhwb3J0IGNvbnN0IHNsaWRlT3V0WSA9ICh0bzogc3RyaW5nKSA9PiBjcmVhdGVTbGlkZU91dEFuaW1hdGlvbih0bywgJ1knKTtcbmV4cG9ydCBjb25zdCBzbGlkZU91dERvd24gPSBzbGlkZU91dFkoJzEwMCUnKTtcbmV4cG9ydCBjb25zdCBzbGlkZU91dFVwID0gc2xpZGVPdXRZKCctMTAwJScpO1xuZXhwb3J0IGNvbnN0IHNsaWRlT3V0TGVmdCA9IHNsaWRlT3V0WCgnLTEwMCUnKTtcbmV4cG9ydCBjb25zdCBzbGlkZU91dFJpZ2h0ID0gc2xpZGVPdXRYKCcxMDAlJyk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/animations/lib/wait-for-child-animations.mjs

@@ -1,3 +1,41 @@
 import { animateChild, query, transition } from '@angular/animations';
+/**
+ * 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.
+ */
 export const waitForChildAnimations = transition(':enter, :leave', [query('@*', animateChild(), { optional: true })]);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdC1mb3ItY2hpbGQtYW5pbWF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9hbmltYXRpb25zL3NyYy9saWIvd2FpdC1mb3ItY2hpbGQtYW5pbWF0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV0RSxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxVQUFVLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYW5pbWF0ZUNoaWxkLCBxdWVyeSwgdHJhbnNpdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2FuaW1hdGlvbnMnO1xuXG5leHBvcnQgY29uc3Qgd2FpdEZvckNoaWxkQW5pbWF0aW9ucyA9IHRyYW5zaXRpb24oJzplbnRlciwgOmxlYXZlJywgW3F1ZXJ5KCdAKicsIGFuaW1hdGVDaGlsZCgpLCB7IG9wdGlvbmFsOiB0cnVlIH0pXSk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/breakpoints/lib/breakpoints.config.mjs

@@ -1,5 +1,20 @@
 import { createConfigTokens } from '@odx/angular/utils';
 import { configureBreakpoint } from './helpers/configure-breakpoint';
+/**
+ * Defines default responsive breakpoints for the application. These breakpoints are used to
+ * apply responsive styles and behaviors across various device sizes. Each breakpoint is
+ * configured with a name, a minimum width, and a maximum width, defining the range of device
+ * sizes it targets.
+ *
+ * @constant
+ * @type {Record<string, string>}
+ *
+ * @example
+ * ```ts
+ * // Accessing a breakpoint value
+ * console.log(DEFAULT_BREAKPOINTS['=phone']); // Outputs: "(min-width: 480px) and (max-width: 767px)"
+ * ```
+ */
 export const DEFAULT_BREAKPOINTS = {
     ...configureBreakpoint('phone-s', 360, 480),
     ...configureBreakpoint('phone', 480, 768),
@@ -7,7 +22,30 @@ export const DEFAULT_BREAKPOINTS = {
     ...configureBreakpoint('desktop-s', 960, 1200),
     ...configureBreakpoint('desktop', 1200, 9999),
 };
+/**
+ * Provides Angular dependency injection tokens for accessing and configuring breakpoints
+ * within the application. This enables a type-safe and modular way to manage responsive
+ * design breakpoints across the app.
+ *
+ * @example
+ * ```ts
+ * // Providing custom breakpoints in an Angular module
+ * import { NgModule } from '@angular/core';
+ * import { provideBreakpointsConfig } from '@odx/angular/breakpoints';
+ *
+ * @NgModule({
+ *   providers: [
+ *     provideBreakpointsConfig({
+ *       breakpoints: {
+ *         ...configureBreakpoint('custom-tablet', 640, 1024),
+ *       },
+ *     }),
+ *   ],
+ * })
+ * export class CustomModule {}
+ * ```
+ */
 export const { BreakpointsConfig, BreakpointsDefaultConfig, injectBreakpointsConfig, provideBreakpointsConfig } = createConfigTokens('Breakpoints', '@odx/angular/breakpoints', {
     breakpoints: DEFAULT_BREAKPOINTS,
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/breakpoints/lib/breakpoints.service.mjs

@@ -3,15 +3,58 @@ import { inject, Injectable } from '@angular/core';
 import { distinctUntilChanged, map, of, shareReplay } from 'rxjs';
 import { injectBreakpointsConfig } from './breakpoints.config';
 import * as i0 from "@angular/core";
+/**
+ * Service to observe and react to changes in viewport size based on predefined breakpoints.
+ * Utilizes Angular CDK's BreakpointObserver for listening to media query changes and integrates
+ * it with the application's custom breakpoints configuration.
+ *
+ * @Injectable({ providedIn: 'root' })
+ */
 export class BreakpointsService {
     constructor() {
         this.breakpointObserver = inject(BreakpointObserver);
         this.config = injectBreakpointsConfig();
     }
+    /**
+     * Observes the specified breakpoints and returns an Observable that emits true if any
+     * of the specified breakpoints match the current viewport size, and false otherwise.
+     *
+     * @param {BreakpointName[]} breakpoints - An array of breakpoints to observe.
+     * @returns {Observable<boolean>} - An Observable that emits true if the viewport matches the specified breakpoints.
+     *
+     * @example
+     * ```ts
+     * // Component that uses BreakpointsService to apply dynamic styles based on breakpoints
+     * @Component({
+     *   selector: 'app-responsive-component',
+     *   templateUrl: './responsive-component.component.html',
+     * })
+     * export class ResponsiveComponent {
+     *   isMobile$: Observable<boolean>;
+     *
+     *   constructor(private breakpointsService: BreakpointsService) {
+     *     this.isMobile$ = this.breakpointsService.observe(['phone', 'tablet']);
+     *   }
+     * }
+     * ```
+     */
     observe(breakpoints) {
         const mediaQueries = this.getMediaQueries(breakpoints);
         return this.createBreakpointObserver(mediaQueries);
     }
+    /**
+     * Checks if any of the specified breakpoints match the current viewport size.
+     *
+     * @param {BreakpointName[]} breakpoints - An array of breakpoints to check.
+     * @returns {boolean} - Returns true if the viewport matches the specified breakpoints, false otherwise.
+     *
+     * @example
+     * ```ts
+     * // Checking if the current viewport matches the 'desktop' breakpoint
+     * const isDesktop = this.breakpointsService.matches(['desktop']);
+     * console.log(`Is desktop view? ${isDesktop}`);
+     * ```
+     */
     matches(breakpoints) {
         const mediaQueries = this.getMediaQueries(breakpoints);
         return this.breakpointObserver.isMatched(mediaQueries);
@@ -31,4 +74,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/breakpoints/lib/directives/match-breakpoints.directive.mjs

@@ -3,6 +3,31 @@ import { coerceArray, untilDestroyed } from '@odx/angular/utils';
 import { BehaviorSubject, switchMap, tap } from 'rxjs';
 import { BreakpointsService } from '../breakpoints.service';
 import * as i0 from "@angular/core";
+/**
+ * A structural directive that conditionally includes an Angular template based on whether the viewport matches
+ * specified breakpoints. It leverages the BreakpointsService to observe changes in viewport size and apply
+ * the appropriate template.
+ *
+ * @Directive
+ * @param {BreakpointsService} breakpointsService - Injects BreakpointsService to observe breakpoint changes.
+ * @param {TemplateRef} template - Injects the Angular template to render when breakpoints match.
+ * @param {ViewContainerRef} viewContainer - Injects the container where the template will be rendered.
+ *
+ * @example
+ * ```html
+ * // Usage in a component template to conditionally display content based on breakpoints
+ * // Assume 'mobile' and 'tablet' are defined breakpoints
+ * <ng-template [odxMatchBreakpoints]="['mobile', 'tablet']">
+ *   Content to display on mobile and tablet sizes.
+ * </ng-template>
+ * <ng-template [odxMatchBreakpoints]="['desktop']" [odxMatchBreakpointsElse]="elseTemplate">
+ *   Content to display on desktop size.
+ * </ng-template>
+ * <ng-template #elseTemplate>
+ *   Content to display when not on desktop size.
+ * </ng-template>
+ * ```
+ */
 export class MatchBreakpointsDirective {
     constructor() {
         this.breakpoints$$ = new BehaviorSubject([]);
@@ -10,9 +35,20 @@ export class MatchBreakpointsDirective {
         this.takeUntilDestroyed = untilDestroyed();
         this.template = inject(TemplateRef);
         this.viewContainer = inject(ViewContainerRef);
+        /**
+         * Optionally specifies a template to render when the viewport does not match the specified breakpoints.
+         *
+         * @param {TemplateRef<unknown>} elseTemplate - The template to render when the viewport does not match the breakpoints.
+         */
         // eslint-disable-next-line @angular-eslint/no-input-rename
         this.elseTemplate = null;
     }
+    /**
+     * Sets the breakpoints to observe. The directive's content is displayed if the current viewport matches
+     * any of the specified breakpoints.
+     *
+     * @param {BreakpointName | BreakpointName[]} value - The breakpoint(s) to match against the current viewport size.
+     */
     set breakpoints(value) {
         this.breakpoints$$.next(coerceArray(value ?? []));
     }
@@ -45,4 +81,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: ['odxMatchBreakpointsElse']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/breakpoints/lib/helpers/configure-breakpoint.mjs

@@ -1,3 +1,22 @@
+/**
+ * Generates a configuration object containing CSS media query strings for a named breakpoint.
+ * The function creates media queries for three scenarios: below (`<`), exactly (`=`), and above (`>`) the specified breakpoint.
+ *
+ * @template T - The string literal type representing the name of the breakpoint.
+ * @param {T} name - The name of the breakpoint (e.g., 'md' for medium).
+ * @param {number} min - The minimum width (inclusive) where the breakpoint starts.
+ * @param {number} max - The maximum width (exclusive) where the breakpoint ends.
+ * @returns {BreakpointConfig<T>} An object containing media query strings for targeting screen sizes relative to the breakpoint.
+ *
+ * @example
+ * ```ts
+ * // Define a medium (md) breakpoint
+ * const mdBreakpoint = configureBreakpoint('md', 768, 1024);
+ * console.log(mdBreakpoint['<md']); // Outputs: "(max-width: 767px)"
+ * console.log(mdBreakpoint['=md']); // Outputs: "(min-width: 768px) and (max-width: 1023px)"
+ * console.log(mdBreakpoint['>md']); // Outputs: "(min-width: 768px)"
+ * ```
+ */
 export function configureBreakpoint(name, min, max) {
     return {
         [`<${name}`]: `(max-width: ${min - 1}px)`,
@@ -5,4 +24,4 @@ export function configureBreakpoint(name, min, max) {
         [`>${name}`]: `(min-width: ${min}px)`,
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJlLWJyZWFrcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvYnJlYWtwb2ludHMvc3JjL2xpYi9oZWxwZXJzL2NvbmZpZ3VyZS1icmVha3BvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sVUFBVSxtQkFBbUIsQ0FBbUIsSUFBTyxFQUFFLEdBQVcsRUFBRSxHQUFXO0lBQ3JGLE9BQU87UUFDTCxDQUFDLElBQUksSUFBSSxFQUFXLENBQUMsRUFBRSxlQUFlLEdBQUcsR0FBRyxDQUFDLEtBQUs7UUFDbEQsQ0FBQyxJQUFJLElBQUksRUFBVyxDQUFDLEVBQUUsZUFBZSxHQUFHLHVCQUF1QixHQUFHLEdBQUcsQ0FBQyxLQUFLO1FBQzVFLENBQUMsSUFBSSxJQUFJLEVBQVcsQ0FBQyxFQUFFLGVBQWUsR0FBRyxLQUFLO0tBQ3hCLENBQUM7QUFDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbInR5cGUgQnJlYWtwb2ludE9wZXJhdG9ycyA9ICc8JyB8ICc9JyB8ICc+JztcbnR5cGUgQnJlYWtwb2ludENvbmZpZzxUIGV4dGVuZHMgc3RyaW5nPiA9IFJlY29yZDxgJHtCcmVha3BvaW50T3BlcmF0b3JzfSR7VH1gLCBzdHJpbmc+O1xuXG5leHBvcnQgZnVuY3Rpb24gY29uZmlndXJlQnJlYWtwb2ludDxUIGV4dGVuZHMgc3RyaW5nPihuYW1lOiBULCBtaW46IG51bWJlciwgbWF4OiBudW1iZXIpOiBCcmVha3BvaW50Q29uZmlnPFQ+IHtcbiAgcmV0dXJuIHtcbiAgICBbYDwke25hbWV9YCBhcyBjb25zdF06IGAobWF4LXdpZHRoOiAke21pbiAtIDF9cHgpYCxcbiAgICBbYD0ke25hbWV9YCBhcyBjb25zdF06IGAobWluLXdpZHRoOiAke21pbn1weCkgYW5kIChtYXgtd2lkdGg6ICR7bWF4IC0gMX1weClgLFxuICAgIFtgPiR7bmFtZX1gIGFzIGNvbnN0XTogYChtaW4td2lkdGg6ICR7bWlufXB4KWAsXG4gIH0gYXMgQnJlYWtwb2ludENvbmZpZzxUPjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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