@odx/angular 6.0.0 → 6.0.1

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,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
+//# 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2gtYnJlYWtwb2ludHMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2JyZWFrcG9pbnRzL3NyYy9saWIvZGlyZWN0aXZlcy9tYXRjaC1icmVha3BvaW50cy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFVLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNoRyxPQUFPLEVBQUUsV0FBVyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxlQUFlLEVBQUUsU0FBUyxFQUFFLEdBQUcsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN2RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFHNUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXdCRztBQUtILE1BQU0sT0FBTyx5QkFBeUI7SUFKdEM7UUFLbUIsa0JBQWEsR0FBRyxJQUFJLGVBQWUsQ0FBbUIsRUFBRSxDQUFDLENBQUM7UUFDMUQsdUJBQWtCLEdBQUcsTUFBTSxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFDaEQsdUJBQWtCLEdBQUcsY0FBYyxFQUFFLENBQUM7UUFDdEMsYUFBUSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUMvQixrQkFBYSxHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBYTFEOzs7O1dBSUc7UUFDSCwyREFBMkQ7UUFFcEQsaUJBQVksR0FBaUMsSUFBSSxDQUFDO0tBb0IxRDtJQXRDQzs7Ozs7T0FLRztJQUNILElBQ1csV0FBVyxDQUFDLEtBQTJEO1FBQ2hGLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNwRCxDQUFDO0lBV00sUUFBUTtRQUNiLElBQUksQ0FBQyxhQUFhO2FBQ2YsSUFBSSxDQUNILFNBQVMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxFQUN4RSxHQUFHLENBQUMsQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLEVBQzVELElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUMxQjthQUNBLFNBQVMsRUFBRSxDQUFDO0lBQ2pCLENBQUM7SUFFTyxNQUFNLENBQUMsa0JBQTJCO1FBQ3hDLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDM0IsTUFBTSxRQUFRLEdBQUcsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUM7UUFDeEUsSUFBSSxRQUFRLEVBQUU7WUFDWixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2hFLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQztTQUN4QjtJQUNILENBQUM7K0dBNUNVLHlCQUF5QjttR0FBekIseUJBQXlCOzs0RkFBekIseUJBQXlCO2tCQUpyQyxTQUFTO21CQUFDO29CQUNULFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUUsa0NBQWtDO2lCQUM3Qzs4QkFlWSxXQUFXO3NCQURyQixLQUFLO3VCQUFDLHFCQUFxQjtnQkFZckIsWUFBWTtzQkFEbEIsS0FBSzt1QkFBQyx5QkFBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgSW5wdXQsIE9uSW5pdCwgVGVtcGxhdGVSZWYsIFZpZXdDb250YWluZXJSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGNvZXJjZUFycmF5LCB1bnRpbERlc3Ryb3llZCB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIHN3aXRjaE1hcCwgdGFwIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBCcmVha3BvaW50c1NlcnZpY2UgfSBmcm9tICcuLi9icmVha3BvaW50cy5zZXJ2aWNlJztcbmltcG9ydCB7IEJyZWFrcG9pbnROYW1lIH0gZnJvbSAnLi4vbW9kZWxzJztcblxuLyoqXG4gKiBBIHN0cnVjdHVyYWwgZGlyZWN0aXZlIHRoYXQgY29uZGl0aW9uYWxseSBpbmNsdWRlcyBhbiBBbmd1bGFyIHRlbXBsYXRlIGJhc2VkIG9uIHdoZXRoZXIgdGhlIHZpZXdwb3J0IG1hdGNoZXNcbiAqIHNwZWNpZmllZCBicmVha3BvaW50cy4gSXQgbGV2ZXJhZ2VzIHRoZSBCcmVha3BvaW50c1NlcnZpY2UgdG8gb2JzZXJ2ZSBjaGFuZ2VzIGluIHZpZXdwb3J0IHNpemUgYW5kIGFwcGx5XG4gKiB0aGUgYXBwcm9wcmlhdGUgdGVtcGxhdGUuXG4gKlxuICogQERpcmVjdGl2ZVxuICogQHBhcmFtIHtCcmVha3BvaW50c1NlcnZpY2V9IGJyZWFrcG9pbnRzU2VydmljZSAtIEluamVjdHMgQnJlYWtwb2ludHNTZXJ2aWNlIHRvIG9ic2VydmUgYnJlYWtwb2ludCBjaGFuZ2VzLlxuICogQHBhcmFtIHtUZW1wbGF0ZVJlZn0gdGVtcGxhdGUgLSBJbmplY3RzIHRoZSBBbmd1bGFyIHRlbXBsYXRlIHRvIHJlbmRlciB3aGVuIGJyZWFrcG9pbnRzIG1hdGNoLlxuICogQHBhcmFtIHtWaWV3Q29udGFpbmVyUmVmfSB2aWV3Q29udGFpbmVyIC0gSW5qZWN0cyB0aGUgY29udGFpbmVyIHdoZXJlIHRoZSB0ZW1wbGF0ZSB3aWxsIGJlIHJlbmRlcmVkLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGBodG1sXG4gKiAvLyBVc2FnZSBpbiBhIGNvbXBvbmVudCB0ZW1wbGF0ZSB0byBjb25kaXRpb25hbGx5IGRpc3BsYXkgY29udGVudCBiYXNlZCBvbiBicmVha3BvaW50c1xuICogLy8gQXNzdW1lICdtb2JpbGUnIGFuZCAndGFibGV0JyBhcmUgZGVmaW5lZCBicmVha3BvaW50c1xuICogPG5nLXRlbXBsYXRlIFtvZHhNYXRjaEJyZWFrcG9pbnRzXT1cIlsnbW9iaWxlJywgJ3RhYmxldCddXCI+XG4gKiAgIENvbnRlbnQgdG8gZGlzcGxheSBvbiBtb2JpbGUgYW5kIHRhYmxldCBzaXplcy5cbiAqIDwvbmctdGVtcGxhdGU+XG4gKiA8bmctdGVtcGxhdGUgW29keE1hdGNoQnJlYWtwb2ludHNdPVwiWydkZXNrdG9wJ11cIiBbb2R4TWF0Y2hCcmVha3BvaW50c0Vsc2VdPVwiZWxzZVRlbXBsYXRlXCI+XG4gKiAgIENvbnRlbnQgdG8gZGlzcGxheSBvbiBkZXNrdG9wIHNpemUuXG4gKiA8L25nLXRlbXBsYXRlPlxuICogPG5nLXRlbXBsYXRlICNlbHNlVGVtcGxhdGU+XG4gKiAgIENvbnRlbnQgdG8gZGlzcGxheSB3aGVuIG5vdCBvbiBkZXNrdG9wIHNpemUuXG4gKiA8L25nLXRlbXBsYXRlPlxuICogYGBgXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzdGFuZGFsb25lOiB0cnVlLFxuICBzZWxlY3RvcjogJ25nLXRlbXBsYXRlW29keE1hdGNoQnJlYWtwb2ludHNdJyxcbn0pXG5leHBvcnQgY2xhc3MgTWF0Y2hCcmVha3BvaW50c0RpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIHByaXZhdGUgcmVhZG9ubHkgYnJlYWtwb2ludHMkJCA9IG5ldyBCZWhhdmlvclN1YmplY3Q8QnJlYWtwb2ludE5hbWVbXT4oW10pO1xuICBwcml2YXRlIHJlYWRvbmx5IGJyZWFrcG9pbnRzU2VydmljZSA9IGluamVjdChCcmVha3BvaW50c1NlcnZpY2UpO1xuICBwcml2YXRlIHJlYWRvbmx5IHRha2VVbnRpbERlc3Ryb3llZCA9IHVudGlsRGVzdHJveWVkKCk7XG4gIHByaXZhdGUgcmVhZG9ubHkgdGVtcGxhdGUgPSBpbmplY3QoVGVtcGxhdGVSZWYpO1xuICBwcml2YXRlIHJlYWRvbmx5IHZpZXdDb250YWluZXIgPSBpbmplY3QoVmlld0NvbnRhaW5lclJlZik7XG5cbiAgLyoqXG4gICAqIFNldHMgdGhlIGJyZWFrcG9pbnRzIHRvIG9ic2VydmUuIFRoZSBkaXJlY3RpdmUncyBjb250ZW50IGlzIGRpc3BsYXllZCBpZiB0aGUgY3VycmVudCB2aWV3cG9ydCBtYXRjaGVzXG4gICAqIGFueSBvZiB0aGUgc3BlY2lmaWVkIGJyZWFrcG9pbnRzLlxuICAgKlxuICAgKiBAcGFyYW0ge0JyZWFrcG9pbnROYW1lIHwgQnJlYWtwb2ludE5hbWVbXX0gdmFsdWUgLSBUaGUgYnJlYWtwb2ludChzKSB0byBtYXRjaCBhZ2FpbnN0IHRoZSBjdXJyZW50IHZpZXdwb3J0IHNpemUuXG4gICAqL1xuICBASW5wdXQoJ29keE1hdGNoQnJlYWtwb2ludHMnKVxuICBwdWJsaWMgc2V0IGJyZWFrcG9pbnRzKHZhbHVlOiBCcmVha3BvaW50TmFtZSB8IEJyZWFrcG9pbnROYW1lW10gfCBudWxsIHwgdW5kZWZpbmVkKSB7XG4gICAgdGhpcy5icmVha3BvaW50cyQkLm5leHQoY29lcmNlQXJyYXkodmFsdWUgPz8gW10pKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBPcHRpb25hbGx5IHNwZWNpZmllcyBhIHRlbXBsYXRlIHRvIHJlbmRlciB3aGVuIHRoZSB2aWV3cG9ydCBkb2VzIG5vdCBtYXRjaCB0aGUgc3BlY2lmaWVkIGJyZWFrcG9pbnRzLlxuICAgKlxuICAgKiBAcGFyYW0ge1RlbXBsYXRlUmVmPHVua25vd24+fSBlbHNlVGVtcGxhdGUgLSBUaGUgdGVtcGxhdGUgdG8gcmVuZGVyIHdoZW4gdGhlIHZpZXdwb3J0IGRvZXMgbm90IG1hdGNoIHRoZSBicmVha3BvaW50cy5cbiAgICovXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvbm8taW5wdXQtcmVuYW1lXG4gIEBJbnB1dCgnb2R4TWF0Y2hCcmVha3BvaW50c0Vsc2UnKVxuICBwdWJsaWMgZWxzZVRlbXBsYXRlPzogVGVtcGxhdGVSZWY8dW5rbm93bj4gfCBudWxsID0gbnVsbDtcblxuICBwdWJsaWMgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgdGhpcy5icmVha3BvaW50cyQkXG4gICAgICAucGlwZShcbiAgICAgICAgc3dpdGNoTWFwKChicmVha3BvaW50cykgPT4gdGhpcy5icmVha3BvaW50c1NlcnZpY2Uub2JzZXJ2ZShicmVha3BvaW50cykpLFxuICAgICAgICB0YXAoKG1hdGNoZXNCcmVha3BvaW50cykgPT4gdGhpcy5yZW5kZXIobWF0Y2hlc0JyZWFrcG9pbnRzKSksXG4gICAgICAgIHRoaXMudGFrZVVudGlsRGVzdHJveWVkKCksXG4gICAgICApXG4gICAgICAuc3Vic2NyaWJlKCk7XG4gIH1cblxuICBwcml2YXRlIHJlbmRlcihtYXRjaGVzQnJlYWtwb2ludHM6IGJvb2xlYW4pOiB2b2lkIHtcbiAgICB0aGlzLnZpZXdDb250YWluZXIuY2xlYXIoKTtcbiAgICBjb25zdCB0ZW1wbGF0ZSA9IG1hdGNoZXNCcmVha3BvaW50cyA/IHRoaXMudGVtcGxhdGUgOiB0aGlzLmVsc2VUZW1wbGF0ZTtcbiAgICBpZiAodGVtcGxhdGUpIHtcbiAgICAgIGNvbnN0IHZpZXdSZWYgPSB0aGlzLnZpZXdDb250YWluZXIuY3JlYXRlRW1iZWRkZWRWaWV3KHRlbXBsYXRlKTtcbiAgICAgIHZpZXdSZWYubWFya0ZvckNoZWNrKCk7XG4gICAgfVxuICB9XG59XG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJlLWJyZWFrcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvYnJlYWtwb2ludHMvc3JjL2xpYi9oZWxwZXJzL2NvbmZpZ3VyZS1icmVha3BvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FrQkc7QUFDSCxNQUFNLFVBQVUsbUJBQW1CLENBQW1CLElBQU8sRUFBRSxHQUFXLEVBQUUsR0FBVztJQUNyRixPQUFPO1FBQ0wsQ0FBQyxJQUFJLElBQUksRUFBVyxDQUFDLEVBQUUsZUFBZSxHQUFHLEdBQUcsQ0FBQyxLQUFLO1FBQ2xELENBQUMsSUFBSSxJQUFJLEVBQVcsQ0FBQyxFQUFFLGVBQWUsR0FBRyx1QkFBdUIsR0FBRyxHQUFHLENBQUMsS0FBSztRQUM1RSxDQUFDLElBQUksSUFBSSxFQUFXLENBQUMsRUFBRSxlQUFlLEdBQUcsS0FBSztLQUN4QixDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJ0eXBlIEJyZWFrcG9pbnRPcGVyYXRvcnMgPSAnPCcgfCAnPScgfCAnPic7XG50eXBlIEJyZWFrcG9pbnRDb25maWc8VCBleHRlbmRzIHN0cmluZz4gPSBSZWNvcmQ8YCR7QnJlYWtwb2ludE9wZXJhdG9yc30ke1R9YCwgc3RyaW5nPjtcblxuLyoqXG4gKiBHZW5lcmF0ZXMgYSBjb25maWd1cmF0aW9uIG9iamVjdCBjb250YWluaW5nIENTUyBtZWRpYSBxdWVyeSBzdHJpbmdzIGZvciBhIG5hbWVkIGJyZWFrcG9pbnQuXG4gKiBUaGUgZnVuY3Rpb24gY3JlYXRlcyBtZWRpYSBxdWVyaWVzIGZvciB0aHJlZSBzY2VuYXJpb3M6IGJlbG93IChgPGApLCBleGFjdGx5IChgPWApLCBhbmQgYWJvdmUgKGA+YCkgdGhlIHNwZWNpZmllZCBicmVha3BvaW50LlxuICpcbiAqIEB0ZW1wbGF0ZSBUIC0gVGhlIHN0cmluZyBsaXRlcmFsIHR5cGUgcmVwcmVzZW50aW5nIHRoZSBuYW1lIG9mIHRoZSBicmVha3BvaW50LlxuICogQHBhcmFtIHtUfSBuYW1lIC0gVGhlIG5hbWUgb2YgdGhlIGJyZWFrcG9pbnQgKGUuZy4sICdtZCcgZm9yIG1lZGl1bSkuXG4gKiBAcGFyYW0ge251bWJlcn0gbWluIC0gVGhlIG1pbmltdW0gd2lkdGggKGluY2x1c2l2ZSkgd2hlcmUgdGhlIGJyZWFrcG9pbnQgc3RhcnRzLlxuICogQHBhcmFtIHtudW1iZXJ9IG1heCAtIFRoZSBtYXhpbXVtIHdpZHRoIChleGNsdXNpdmUpIHdoZXJlIHRoZSBicmVha3BvaW50IGVuZHMuXG4gKiBAcmV0dXJucyB7QnJlYWtwb2ludENvbmZpZzxUPn0gQW4gb2JqZWN0IGNvbnRhaW5pbmcgbWVkaWEgcXVlcnkgc3RyaW5ncyBmb3IgdGFyZ2V0aW5nIHNjcmVlbiBzaXplcyByZWxhdGl2ZSB0byB0aGUgYnJlYWtwb2ludC5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIERlZmluZSBhIG1lZGl1bSAobWQpIGJyZWFrcG9pbnRcbiAqIGNvbnN0IG1kQnJlYWtwb2ludCA9IGNvbmZpZ3VyZUJyZWFrcG9pbnQoJ21kJywgNzY4LCAxMDI0KTtcbiAqIGNvbnNvbGUubG9nKG1kQnJlYWtwb2ludFsnPG1kJ10pOyAvLyBPdXRwdXRzOiBcIihtYXgtd2lkdGg6IDc2N3B4KVwiXG4gKiBjb25zb2xlLmxvZyhtZEJyZWFrcG9pbnRbJz1tZCddKTsgLy8gT3V0cHV0czogXCIobWluLXdpZHRoOiA3NjhweCkgYW5kIChtYXgtd2lkdGg6IDEwMjNweClcIlxuICogY29uc29sZS5sb2cobWRCcmVha3BvaW50Wyc+bWQnXSk7IC8vIE91dHB1dHM6IFwiKG1pbi13aWR0aDogNzY4cHgpXCJcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gY29uZmlndXJlQnJlYWtwb2ludDxUIGV4dGVuZHMgc3RyaW5nPihuYW1lOiBULCBtaW46IG51bWJlciwgbWF4OiBudW1iZXIpOiBCcmVha3BvaW50Q29uZmlnPFQ+IHtcbiAgcmV0dXJuIHtcbiAgICBbYDwke25hbWV9YCBhcyBjb25zdF06IGAobWF4LXdpZHRoOiAke21pbiAtIDF9cHgpYCxcbiAgICBbYD0ke25hbWV9YCBhcyBjb25zdF06IGAobWluLXdpZHRoOiAke21pbn1weCkgYW5kIChtYXgtd2lkdGg6ICR7bWF4IC0gMX1weClgLFxuICAgIFtgPiR7bmFtZX1gIGFzIGNvbnN0XTogYChtaW4td2lkdGg6ICR7bWlufXB4KWAsXG4gIH0gYXMgQnJlYWtwb2ludENvbmZpZzxUPjtcbn1cbiJdfQ==

package/esm2022/cdk/a11y/lib/directives/interactive.directive.mjs

@@ -5,10 +5,42 @@ import { CSSComponent } from '@odx/angular/internal';
 import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * Directive that makes an element interactive, responding to click, Enter key, and Space key events.
+ * It automatically handles the disabled state through `DisabledController`, inhibiting interactions when disabled.
+ * This directive can be useful for creating custom buttons or interactive elements that are not natively interactive,
+ * such as divs or custom components.
+ *
+ * @Directive
+ * @CSSComponent cdk-interactive - A CSS Component class that can be targeted for styling interactive elements.
+ * @selector '[odxCdkInteractive]' - Applies this directive to any element with the 'odxCdkInteractive' attribute.
+ * @hostDirectives {WithDisabledState, WithTabIndex} - Applies disabled state and tab index handling.
+ * @host role='button' - Assigns a role of 'button' to the host element for accessibility.
+ *
+ * @example
+ * Applying the directive to a div element to make it interactive:
+ * ```html
+ * <div odxCdkInteractive (odxCdkInteractive)="onInteract($event)">
+ *   Click or press Enter/Space to interact
+ * </div>
+ * ```
+ *
+ * @example
+ * Using the directive on a custom Angular component
+ * ```html
+ * <app-custom-button odxCdkInteractive (odxCdkInteractive)="onCustomButtonInteract($event)">
+ * </app-custom-button>
+ * ```
+ */
 export let InteractiveDirective = class InteractiveDirective {
     constructor() {
         this.disabledController = DisabledController.inject();
         this.element = injectElement();
+        /**
+         * Emits an event when the element is interacted with via click, Enter key, or Space key.
+         *
+         * @emits {MouseEvent | KeyboardEvent} - The event that triggered the interaction.
+         */
         this.interact = new EventEmitter();
     }
     handleEvents(event) {
@@ -45,4 +77,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: HostListener,
                 args: ['keyup.space', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/a11y/lib/directives/list-focus-manager-option.directive.mjs

@@ -2,14 +2,36 @@ import { Directive } from '@angular/core';
 import { DisabledController } from '@odx/angular';
 import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * Directive to make an element focusable as part of a list, integrating with Angular CDK's FocusKeyManager.
+ * It listens to the disabled state controlled by `DisabledController` to manage focus correctly based on
+ * the enabled state of the element.
+ *
+ * @example
+ * In a component template, apply this directive to list items that should be focusable and managed by a FocusKeyManager:
+ * ```html
+ * <li odxListFocusManagerOption *ngFor="let item of items">
+ *   {{ item }}
+ * </li>
+ * ```
+ */
 export class ListFocusManagerOptionDirective {
     constructor() {
         this.disabledController = DisabledController.inject();
         this.element = injectElement();
     }
+    /**
+     * Reflects the disabled state of the element, managed by `DisabledController`.
+     * If disabled, the element is not focusable.
+     *
+     * @returns {boolean} True if the directive's host element is disabled.
+     */
     get disabled() {
         return !!this.disabledController?.disabled;
     }
+    /**
+     * Focuses the host element. If the element is disabled, it will not be focused.
+     */
     focus() {
         this.element.nativeElement.focus();
     }
@@ -23,4 +45,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     standalone: true,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1mb2N1cy1tYW5hZ2VyLW9wdGlvbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2ExMXkvc3JjL2xpYi9kaXJlY3RpdmVzL2xpc3QtZm9jdXMtbWFuYWdlci1vcHRpb24uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDMUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2xELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFNbkQsTUFBTSxPQUFPLCtCQUErQjtJQUo1QztRQUttQix1QkFBa0IsR0FBRyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNqRCxZQUFPLEdBQUcsYUFBYSxFQUFFLENBQUM7S0FTNUM7SUFQQyxJQUFXLFFBQVE7UUFDakIsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLGtCQUFrQixFQUFFLFFBQVEsQ0FBQztJQUM3QyxDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JDLENBQUM7K0dBVlUsK0JBQStCO21HQUEvQiwrQkFBK0I7OzRGQUEvQiwrQkFBK0I7a0JBSjNDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLDZCQUE2QjtvQkFDdkMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9jdXNhYmxlT3B0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuaW1wb3J0IHsgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEaXNhYmxlZENvbnRyb2xsZXIgfSBmcm9tICdAb2R4L2FuZ3VsYXInO1xuaW1wb3J0IHsgaW5qZWN0RWxlbWVudCB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tvZHhMaXN0Rm9jdXNNYW5hZ2VyT3B0aW9uXScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIExpc3RGb2N1c01hbmFnZXJPcHRpb25EaXJlY3RpdmUgaW1wbGVtZW50cyBGb2N1c2FibGVPcHRpb24ge1xuICBwcml2YXRlIHJlYWRvbmx5IGRpc2FibGVkQ29udHJvbGxlciA9IERpc2FibGVkQ29udHJvbGxlci5pbmplY3QoKTtcbiAgcHJpdmF0ZSByZWFkb25seSBlbGVtZW50ID0gaW5qZWN0RWxlbWVudCgpO1xuXG4gIHB1YmxpYyBnZXQgZGlzYWJsZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuICEhdGhpcy5kaXNhYmxlZENvbnRyb2xsZXI/LmRpc2FibGVkO1xuICB9XG5cbiAgcHVibGljIGZvY3VzKCk6IHZvaWQge1xuICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZvY3VzKCk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/a11y/lib/directives/list-focus-manager.directive.mjs

@@ -3,6 +3,23 @@ import { ContentChildren, Directive, HostListener, QueryList } from '@angular/co
 import { deferFn } from '@odx/angular/utils';
 import { ListFocusManagerOptionDirective } from './list-focus-manager-option.directive';
 import * as i0 from "@angular/core";
+/**
+ * Directive that sets up keyboard navigation for a list or a group of focusable elements.
+ * Utilizes `FocusKeyManager` from Angular CDK to manage focus among items.
+ * It automatically skips disabled items and wraps around when navigating past the first or last item.
+ * Handles keydown events to navigate through the focusable options.
+ *
+ * @example
+ * In a component template, use this directive on a container element and `odxListFocusManagerOption`
+ * on each focusable list item:
+ * ```html
+ * <ul odxListFocusManager>
+ *   <li odxListFocusManagerOption *ngFor="let item of items">
+ *     {{ item }}
+ *   </li>
+ * </ul>
+ * ```
+ */
 export class ListFocusManagerDirective {
     constructor() {
         this.keyManager = null;
@@ -37,4 +54,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: HostListener,
                 args: ['keydown', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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