@odx/angular 6.0.0 → 6.1.0

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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

package/esm2022/cdk/active-indicator/lib/active-indicator.directive.mjs

@@ -7,6 +7,42 @@ import { BehaviorSubject, EMPTY, distinctUntilChanged, switchMap } from 'rxjs';
 import { ActiveIndicatorPosition } from './models';
 import { ActiveIndicatorDirection } from './models/active-indicator-direction';
 import * as i0 from "@angular/core";
+/**
+ * `ActiveIndicatorDirective` is designed to adjust an indicator's position and size dynamically to highlight
+ * the active element within a container. It's useful for tabs, menus, or any list where an active state is visually represented.
+ * The directive can be customized to align the indicator based on the active element's position and supports
+ * both horizontal and vertical orientations.
+ *
+ * To use this directive, apply it to the element you want to use as an active indicator.
+ * Then, bind the active element using the `odxActiveIndicator` input. Optionally, specify
+ * the container element with `odxActiveIndicatorParent` if the container is not the immediate parent of the indicator.
+ *
+ * @example
+ * ```html
+ * <div class="tabs-container" #tabsContainer>
+ *   <div class="tab" *ngFor="let tab of tabs" [class.active]="tab.isActive" #tabElement>{{ tab.label }}</div>
+ *   <div class="indicator" [odxActiveIndicator]="activeTabElement" [odxActiveIndicatorParent]="tabsContainer"></div>
+ * </div>
+ * ```
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'app-tabs',
+ *   templateUrl: './tabs.component.html',
+ *   imports: [ActiveIndicatorDirective, NgForOf],
+ * })
+ * export class TabsComponent {
+ *   tabs = [{ label: 'Tab 1', isActive: true }, { label: 'Tab 2', isActive: false }];
+ *   @ViewChildren('tabElement') tabElements?: QueryList<ElementRef>;
+ *   @ViewChild('tabsContainer') tabsContainer!: ElementRef;
+ *
+ *   get activeTabElement(): HTMLElement {
+ *     const activeTab = this.tabElements?.find((tab) => tab.nativeElement.classList.contains('active'));
+ *     return activeTab ? activeTab.nativeElement : null;
+ *   }
+ * }
+ * ```
+ */
 export let ActiveIndicatorDirective = class ActiveIndicatorDirective {
     constructor() {
         this.takeUntilDestroyed = untilDestroyed();
@@ -15,11 +51,38 @@ export let ActiveIndicatorDirective = class ActiveIndicatorDirective {
             return parentElement ? fromElementResize$(parentElement) : EMPTY;
         }));
         this.element = injectElement();
+        /**
+         * Indicates whether the element is active or not.
+         *
+         * @type {boolean}
+         */
         this.isActive = false;
+        /**
+         * The currently active element to which the indicator should align.
+         * It dynamically updates the indicator's position and size based on this element.
+         *
+         * @type {HTMLElement | null}
+         */
         this.activeElement = null;
+        /**
+         * The direction in which the indicator should move.
+         *
+         * @type {ActiveIndicatorDirection}
+         */
         this.direction = ActiveIndicatorDirection.HORIZONTAL;
+        /**
+         * The position of the indicator relative to the active element.
+         *
+         * @type {ActiveIndicatorPosition}
+         */
         this.position = ActiveIndicatorPosition.CENTER;
     }
+    /**
+     * The parent container element of the active elements.
+     * If not set, the indicator's immediate parent element is used.
+     *
+     * @type {HTMLElement | null}
+     */
     set parent(value) {
         this.parentElement$$.next(value);
     }
@@ -124,4 +187,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: ['odxActiveIndicatorPosition']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"active-indicator.directive.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/active-indicator/src/lib/active-indicator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, Input, OnChanges } from '@angular/core';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { fromElementResize$ } from '@odx/angular/rxjs';\nimport { NgChanges, applyStyles, disableCSSTransitions, hasChanged, injectElement, isPresent, px, untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, EMPTY, distinctUntilChanged, switchMap } from 'rxjs';\nimport { ActiveIndicatorPosition } from './models';\nimport { ActiveIndicatorDirection } from './models/active-indicator-direction';\n\n@CSSComponent('cdk-active-indicator')\n@Directive({\n  standalone: true,\n  selector: '[odxActiveIndicator]',\n})\nexport class ActiveIndicatorDirective implements OnChanges, AfterViewInit {\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private readonly parentElement$$ = new BehaviorSubject<HTMLElement | null>(null);\n  private readonly onResize$ = this.parentElement$$.pipe(\n    distinctUntilChanged(),\n    switchMap((parentElement) => {\n      return parentElement ? fromElementResize$(parentElement) : EMPTY;\n    }),\n  );\n\n  public readonly element = injectElement();\n\n  @CSSModifier()\n  public isActive = false;\n\n  @Input('odxActiveIndicator')\n  public activeElement?: HTMLElement | null = null;\n\n  @Input('odxActiveIndicatorParent')\n  public set parent(value: HTMLElement | null) {\n    this.parentElement$$.next(value);\n  }\n  public get parent(): HTMLElement | null {\n    return this.parentElement$$.getValue();\n  }\n\n  @CSSModifier()\n  @Input('odxActiveIndicatorDirection')\n  public direction: ActiveIndicatorDirection = ActiveIndicatorDirection.HORIZONTAL;\n\n  @Input('odxActiveIndicatorPosition')\n  public position: ActiveIndicatorPosition = ActiveIndicatorPosition.CENTER;\n\n  public ngAfterViewInit(): void {\n    this.onResize$.pipe(this.takeUntilDestroyed()).subscribe(() => this.updateStyles());\n    this.parent ??= this.element.nativeElement.parentElement;\n  }\n\n  public ngOnChanges(changes: NgChanges<ActiveIndicatorDirective>): void {\n    if (hasChanged(changes, 'activeElement', false)) {\n      this.isActive = !!this.activeElement;\n    }\n    if (hasChanged(changes, ['activeElement', 'direction', 'position'])) {\n      this.updateStyles(!isPresent(changes.activeElement?.previousValue));\n    }\n  }\n\n  private updateStyles(disableTransition = false): void {\n    if (!this.activeElement) return;\n    const isHorizontal = this.direction === ActiveIndicatorDirection.HORIZONTAL;\n    const isVertical = this.direction === ActiveIndicatorDirection.VERTICAL;\n    const relativeOffset = this.getIndicatorRelativeOffset();\n\n    let transform = null;\n    if (isHorizontal) {\n      const positionX = this.getIndicatorPositionX(this.activeElement);\n      transform = `translateX(${px(positionX)}) translateX(${relativeOffset}%)`;\n    }\n    if (isVertical) {\n      const positionY = this.getIndicatorPositionY(this.activeElement);\n      transform = `translateY(${px(positionY)}) translateY(${relativeOffset}%)`;\n    }\n\n    disableTransition && disableCSSTransitions(this.element.nativeElement, true);\n    applyStyles(this.element.nativeElement, {\n      transform,\n      width: isHorizontal ? px(this.activeElement.offsetWidth) : null,\n      height: isVertical ? px(this.activeElement.offsetHeight) : null,\n    });\n    disableTransition && disableCSSTransitions(this.element.nativeElement, false);\n  }\n\n  private getIndicatorPositionX(activeElement: HTMLElement): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return activeElement.offsetLeft;\n      case ActiveIndicatorPosition.CENTER:\n        return activeElement.offsetLeft + activeElement.offsetWidth / 2;\n      case ActiveIndicatorPosition.END:\n        return activeElement.offsetLeft + activeElement.offsetWidth;\n    }\n  }\n\n  private getIndicatorPositionY(activeElement: HTMLElement): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return activeElement.offsetTop;\n      case ActiveIndicatorPosition.CENTER:\n        return activeElement.offsetTop + activeElement.offsetHeight / 2;\n      case ActiveIndicatorPosition.END:\n        return activeElement.offsetTop + activeElement.offsetHeight;\n    }\n  }\n\n  private getIndicatorRelativeOffset(): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return 0;\n      case ActiveIndicatorPosition.CENTER:\n        return -50;\n      case ActiveIndicatorPosition.END:\n        return -100;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"active-indicator.directive.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/active-indicator/src/lib/active-indicator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, Input, OnChanges } from '@angular/core';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { fromElementResize$ } from '@odx/angular/rxjs';\nimport { NgChanges, applyStyles, disableCSSTransitions, hasChanged, injectElement, isPresent, px, untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, EMPTY, distinctUntilChanged, switchMap } from 'rxjs';\nimport { ActiveIndicatorPosition } from './models';\nimport { ActiveIndicatorDirection } from './models/active-indicator-direction';\n\n/**\n * `ActiveIndicatorDirective` is designed to adjust an indicator's position and size dynamically to highlight\n * the active element within a container. It's useful for tabs, menus, or any list where an active state is visually represented.\n * The directive can be customized to align the indicator based on the active element's position and supports\n * both horizontal and vertical orientations.\n *\n * To use this directive, apply it to the element you want to use as an active indicator.\n * Then, bind the active element using the `odxActiveIndicator` input. Optionally, specify\n * the container element with `odxActiveIndicatorParent` if the container is not the immediate parent of the indicator.\n *\n * @example\n * ```html\n * <div class=\"tabs-container\" #tabsContainer>\n *   <div class=\"tab\" *ngFor=\"let tab of tabs\" [class.active]=\"tab.isActive\" #tabElement>{{ tab.label }}</div>\n *   <div class=\"indicator\" [odxActiveIndicator]=\"activeTabElement\" [odxActiveIndicatorParent]=\"tabsContainer\"></div>\n * </div>\n * ```\n *\n * ```ts\n * @Component({\n *   selector: 'app-tabs',\n *   templateUrl: './tabs.component.html',\n *   imports: [ActiveIndicatorDirective, NgForOf],\n * })\n * export class TabsComponent {\n *   tabs = [{ label: 'Tab 1', isActive: true }, { label: 'Tab 2', isActive: false }];\n *   @ViewChildren('tabElement') tabElements?: QueryList<ElementRef>;\n *   @ViewChild('tabsContainer') tabsContainer!: ElementRef;\n *\n *   get activeTabElement(): HTMLElement {\n *     const activeTab = this.tabElements?.find((tab) => tab.nativeElement.classList.contains('active'));\n *     return activeTab ? activeTab.nativeElement : null;\n *   }\n * }\n * ```\n */\n@CSSComponent('cdk-active-indicator')\n@Directive({\n  standalone: true,\n  selector: '[odxActiveIndicator]',\n})\nexport class ActiveIndicatorDirective implements OnChanges, AfterViewInit {\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private readonly parentElement$$ = new BehaviorSubject<HTMLElement | null>(null);\n  private readonly onResize$ = this.parentElement$$.pipe(\n    distinctUntilChanged(),\n    switchMap((parentElement) => {\n      return parentElement ? fromElementResize$(parentElement) : EMPTY;\n    }),\n  );\n\n  public readonly element = injectElement();\n\n  /**\n   * Indicates whether the element is active or not.\n   *\n   * @type {boolean}\n   */\n  @CSSModifier()\n  public isActive = false;\n\n  /**\n   * The currently active element to which the indicator should align.\n   * It dynamically updates the indicator's position and size based on this element.\n   *\n   * @type {HTMLElement | null}\n   */\n  @Input('odxActiveIndicator')\n  public activeElement?: HTMLElement | null = null;\n\n  /**\n   * The parent container element of the active elements.\n   * If not set, the indicator's immediate parent element is used.\n   *\n   * @type {HTMLElement | null}\n   */\n  @Input('odxActiveIndicatorParent')\n  public set parent(value: HTMLElement | null) {\n    this.parentElement$$.next(value);\n  }\n  public get parent(): HTMLElement | null {\n    return this.parentElement$$.getValue();\n  }\n\n  /**\n   * The direction in which the indicator should move.\n   *\n   * @type {ActiveIndicatorDirection}\n   */\n  @CSSModifier()\n  @Input('odxActiveIndicatorDirection')\n  public direction: ActiveIndicatorDirection = ActiveIndicatorDirection.HORIZONTAL;\n\n  /**\n   * The position of the indicator relative to the active element.\n   *\n   * @type {ActiveIndicatorPosition}\n   */\n  @Input('odxActiveIndicatorPosition')\n  public position: ActiveIndicatorPosition = ActiveIndicatorPosition.CENTER;\n\n  public ngAfterViewInit(): void {\n    this.onResize$.pipe(this.takeUntilDestroyed()).subscribe(() => this.updateStyles());\n    this.parent ??= this.element.nativeElement.parentElement;\n  }\n\n  public ngOnChanges(changes: NgChanges<ActiveIndicatorDirective>): void {\n    if (hasChanged(changes, 'activeElement', false)) {\n      this.isActive = !!this.activeElement;\n    }\n    if (hasChanged(changes, ['activeElement', 'direction', 'position'])) {\n      this.updateStyles(!isPresent(changes.activeElement?.previousValue));\n    }\n  }\n\n  private updateStyles(disableTransition = false): void {\n    if (!this.activeElement) return;\n    const isHorizontal = this.direction === ActiveIndicatorDirection.HORIZONTAL;\n    const isVertical = this.direction === ActiveIndicatorDirection.VERTICAL;\n    const relativeOffset = this.getIndicatorRelativeOffset();\n\n    let transform = null;\n    if (isHorizontal) {\n      const positionX = this.getIndicatorPositionX(this.activeElement);\n      transform = `translateX(${px(positionX)}) translateX(${relativeOffset}%)`;\n    }\n    if (isVertical) {\n      const positionY = this.getIndicatorPositionY(this.activeElement);\n      transform = `translateY(${px(positionY)}) translateY(${relativeOffset}%)`;\n    }\n\n    disableTransition && disableCSSTransitions(this.element.nativeElement, true);\n    applyStyles(this.element.nativeElement, {\n      transform,\n      width: isHorizontal ? px(this.activeElement.offsetWidth) : null,\n      height: isVertical ? px(this.activeElement.offsetHeight) : null,\n    });\n    disableTransition && disableCSSTransitions(this.element.nativeElement, false);\n  }\n\n  private getIndicatorPositionX(activeElement: HTMLElement): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return activeElement.offsetLeft;\n      case ActiveIndicatorPosition.CENTER:\n        return activeElement.offsetLeft + activeElement.offsetWidth / 2;\n      case ActiveIndicatorPosition.END:\n        return activeElement.offsetLeft + activeElement.offsetWidth;\n    }\n  }\n\n  private getIndicatorPositionY(activeElement: HTMLElement): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return activeElement.offsetTop;\n      case ActiveIndicatorPosition.CENTER:\n        return activeElement.offsetTop + activeElement.offsetHeight / 2;\n      case ActiveIndicatorPosition.END:\n        return activeElement.offsetTop + activeElement.offsetHeight;\n    }\n  }\n\n  private getIndicatorRelativeOffset(): number {\n    switch (this.position) {\n      case ActiveIndicatorPosition.START:\n        return 0;\n      case ActiveIndicatorPosition.CENTER:\n        return -50;\n      case ActiveIndicatorPosition.END:\n        return -100;\n    }\n  }\n}\n"]}

package/esm2022/cdk/autocomplete-control/lib/autocomplete-control.mjs

@@ -6,9 +6,24 @@ import { DropdownDirective } from '@odx/angular/components/dropdown';
 import { FormFieldComponent } from '@odx/angular/components/form-field';
 import { injectElement, isFunction, untilDestroyed } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * `AutocompleteControl` is a base directive to enhance an input field with autocomplete functionality,
+ * providing keyboard navigation and selection for options displayed in a dropdown. It's designed to be extended
+ * for specific implementations.
+ * Extends `CustomFormControl` to provide form control behavior and state management.
+ *
+ * @see {CustomFormControl}
+ *
+ * This directive manages the open/close state of the dropdown, the loading state indication, and the interaction between
+ * the autocomplete input and the dropdown options. It utilizes `ActiveDescendantKeyManager` for keyboard navigation among options.
+ *
+ * Extend this directive to create a fully functional autocomplete control tailored to your data type and UI requirements.
+ *
+ * @template T - The type of the items displayed in the autocomplete dropdown.
+ */
 export class AutocompleteControl extends CustomFormControl {
     get dropdownReferenceElement() {
-        return this.formField?.controlElement.nativeElement ?? this.element.nativeElement;
+        return this.formField?.controlElement?.nativeElement ?? this.element?.nativeElement;
     }
     get hasOptions() {
         return !!this.options?.length;
@@ -24,6 +39,18 @@ export class AutocompleteControl extends CustomFormControl {
         this.smoothScrollEnabled = false;
         this.element = injectElement();
         this.isLoading = false;
+        /**
+         * Emits the selected option when an option is selected from the dropdown.
+         *
+         * @emits {T} - The selected option.
+         *
+         * @example
+         * ```ts
+         * autocompleteControl.optionSelected.subscribe((selectedOption) => {
+         *   console.log('Selected option:', selectedOption);
+         * });
+         * ```
+         */
         this.optionSelected = new EventEmitter();
         detectControllerChanges(this).subscribe();
     }
@@ -34,6 +61,17 @@ export class AutocompleteControl extends CustomFormControl {
         this.handleQueryListOption(this.options);
         this.handleSearchFieldChanges();
     }
+    /**
+     * Scrolls the specified option element into view.
+     * @param {OptionControl<T>} option - The option control containing the element to scroll into view.
+     * @returns {void}
+     *
+     * @example
+     * ```ts
+     * const optionControl: OptionControl<string> = { element: myOptionElement };
+     * scrollOptionIntoView(optionControl);
+     * ```
+     */
     scrollOptionIntoView({ element }) {
         const behavior = this.smoothScrollEnabled ? 'smooth' : undefined;
         if (isFunction(element.nativeElement.scrollIntoView)) {
@@ -87,4 +125,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: HostListener,
                 args: ['focusout', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-control.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/autocomplete-control/src/lib/autocomplete-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport {\n  AfterViewInit,\n  booleanAttribute,\n  ChangeDetectorRef,\n  Directive,\n  EventEmitter,\n  HostListener,\n  inject,\n  Input,\n  Output,\n  QueryList,\n  ViewChild,\n} from '@angular/core';\nimport { detectControllerChanges, StringifyFn } from '@odx/angular';\nimport { CustomFormControl, InputControlDirective } from '@odx/angular/cdk/custom-form-control';\nimport { OptionControl } from '@odx/angular/cdk/option-control';\nimport { DropdownDirective } from '@odx/angular/components/dropdown';\nimport { FormFieldComponent } from '@odx/angular/components/form-field';\nimport { injectElement, isFunction, untilDestroyed } from '@odx/angular/utils';\n\n@Directive({\n  standalone: true,\n  host: {\n    '[class.is-open]': 'isOpen',\n    '[attr.aria-disabled]': 'isDisabled || null',\n  },\n})\nexport abstract class AutocompleteControl<T> extends CustomFormControl<T | null> implements AfterViewInit {\n  protected abstract readonly options?: QueryList<OptionControl<T>>;\n\n  protected readonly changeDetector = inject(ChangeDetectorRef);\n  protected readonly formField = inject(FormFieldComponent, { optional: true });\n  protected readonly takeUntilDestroyed = untilDestroyed();\n\n  protected keyManager?: ActiveDescendantKeyManager<OptionControl<T>>;\n  protected smoothScrollEnabled = false;\n\n  @ViewChild(DropdownDirective)\n  protected readonly dropdown?: DropdownDirective;\n\n  public abstract searchField?: InputControlDirective;\n\n  public readonly element = injectElement();\n\n  public get dropdownReferenceElement(): HTMLElement {\n    return this.formField?.controlElement.nativeElement ?? this.element.nativeElement;\n  }\n\n  public get hasOptions(): boolean {\n    return !!this.options?.length;\n  }\n\n  public get isOpen(): boolean {\n    return !!this.dropdown?.isOpen;\n  }\n\n  @Input({ transform: booleanAttribute })\n  public isLoading = false;\n\n  @Input()\n  public stringify?: StringifyFn<T>;\n\n  @Output()\n  public optionSelected = new EventEmitter<T>();\n\n  constructor() {\n    super(null);\n    detectControllerChanges(this).subscribe();\n  }\n\n  public ngAfterViewInit(): void {\n    if (!this.options) return;\n\n    this.initKeyManager(this.options);\n    this.handleQueryListOption(this.options);\n    this.handleSearchFieldChanges();\n  }\n\n  public scrollOptionIntoView({ element }: OptionControl<T>): void {\n    const behavior = this.smoothScrollEnabled ? 'smooth' : undefined;\n    if (isFunction(element.nativeElement.scrollIntoView)) {\n      element.nativeElement.scrollIntoView({ block: 'center', behavior });\n    }\n  }\n\n  protected abstract handleQueryListOption(options: QueryList<OptionControl<T>>): void;\n\n  protected abstract handleSearchFieldChanges(): void;\n\n  protected abstract activateSelectedOption(): void;\n\n  protected initKeyManager(options: QueryList<OptionControl<T>>): void {\n    this.keyManager = new ActiveDescendantKeyManager(options).withHomeAndEnd();\n  }\n\n  protected disableSmoothScroll(): void {\n    this.smoothScrollEnabled = false;\n  }\n\n  protected enableSmoothScroll(): void {\n    this.smoothScrollEnabled = true;\n  }\n\n  protected openDropdown(): void {\n    this.dropdown?.open();\n  }\n\n  protected closeDropdown(): void {\n    this.dropdown?.close();\n  }\n\n  @HostListener('focusout', ['$event'])\n  protected handleFocusOut(event: FocusEvent): void {\n    if (this.isOpen) {\n      event.stopImmediatePropagation();\n    }\n    this.onTouched();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-control.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/autocomplete-control/src/lib/autocomplete-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport {\n  AfterViewInit,\n  booleanAttribute,\n  ChangeDetectorRef,\n  Directive,\n  EventEmitter,\n  HostListener,\n  inject,\n  Input,\n  Output,\n  QueryList,\n  ViewChild,\n} from '@angular/core';\nimport { detectControllerChanges, StringifyFn } from '@odx/angular';\nimport { CustomFormControl, InputControlDirective } from '@odx/angular/cdk/custom-form-control';\nimport { OptionControl } from '@odx/angular/cdk/option-control';\nimport { DropdownDirective } from '@odx/angular/components/dropdown';\nimport { FormFieldComponent } from '@odx/angular/components/form-field';\nimport { injectElement, isFunction, untilDestroyed } from '@odx/angular/utils';\n\n/**\n * `AutocompleteControl` is a base directive to enhance an input field with autocomplete functionality,\n * providing keyboard navigation and selection for options displayed in a dropdown. It's designed to be extended\n * for specific implementations.\n * Extends `CustomFormControl` to provide form control behavior and state management.\n *\n * @see {CustomFormControl}\n *\n * This directive manages the open/close state of the dropdown, the loading state indication, and the interaction between\n * the autocomplete input and the dropdown options. It utilizes `ActiveDescendantKeyManager` for keyboard navigation among options.\n *\n * Extend this directive to create a fully functional autocomplete control tailored to your data type and UI requirements.\n *\n * @template T - The type of the items displayed in the autocomplete dropdown.\n */\n@Directive({\n  standalone: true,\n  host: {\n    '[class.is-open]': 'isOpen',\n    '[attr.aria-disabled]': 'isDisabled || null',\n  },\n})\nexport abstract class AutocompleteControl<T> extends CustomFormControl<T | null> implements AfterViewInit {\n  protected abstract readonly options?: QueryList<OptionControl<T>>;\n\n  protected readonly changeDetector = inject(ChangeDetectorRef);\n  protected readonly formField = inject(FormFieldComponent, { optional: true });\n  protected readonly takeUntilDestroyed = untilDestroyed();\n\n  protected keyManager?: ActiveDescendantKeyManager<OptionControl<T>>;\n  protected smoothScrollEnabled = false;\n\n  @ViewChild(DropdownDirective)\n  protected readonly dropdown?: DropdownDirective;\n\n  public abstract searchField?: InputControlDirective;\n\n  public readonly element = injectElement();\n\n  public get dropdownReferenceElement(): HTMLElement {\n    return this.formField?.controlElement?.nativeElement ?? this.element?.nativeElement;\n  }\n\n  public get hasOptions(): boolean {\n    return !!this.options?.length;\n  }\n\n  public get isOpen(): boolean {\n    return !!this.dropdown?.isOpen;\n  }\n\n  @Input({ transform: booleanAttribute })\n  public isLoading = false;\n\n  /**\n   * A function that converts an item of type T to a string representation.\n   * Used by the AutocompleteControl component to display the selected item.\n   *\n   * @type {StringifyFn<T>}\n   *\n   * @example\n   * ```ts\n   * // Define a stringify function for a custom type Person\n   * const stringifyPerson: StringifyFn<Person> = (person) => `${person.firstName} ${person.lastName}`;\n   *\n   * // Assign the stringify function to the AutocompleteControl\n   * autocompleteControl.stringify = stringifyPerson;\n   * ```\n   */\n  @Input()\n  public stringify?: StringifyFn<T>;\n\n  /**\n   * Emits the selected option when an option is selected from the dropdown.\n   *\n   * @emits {T} - The selected option.\n   *\n   * @example\n   * ```ts\n   * autocompleteControl.optionSelected.subscribe((selectedOption) => {\n   *   console.log('Selected option:', selectedOption);\n   * });\n   * ```\n   */\n  @Output()\n  public optionSelected = new EventEmitter<T>();\n\n  constructor() {\n    super(null);\n    detectControllerChanges(this).subscribe();\n  }\n\n  public ngAfterViewInit(): void {\n    if (!this.options) return;\n\n    this.initKeyManager(this.options);\n    this.handleQueryListOption(this.options);\n    this.handleSearchFieldChanges();\n  }\n\n  /**\n   * Scrolls the specified option element into view.\n   * @param {OptionControl<T>} option - The option control containing the element to scroll into view.\n   * @returns {void}\n   *\n   * @example\n   * ```ts\n   * const optionControl: OptionControl<string> = { element: myOptionElement };\n   * scrollOptionIntoView(optionControl);\n   * ```\n   */\n  public scrollOptionIntoView({ element }: OptionControl<T>): void {\n    const behavior = this.smoothScrollEnabled ? 'smooth' : undefined;\n    if (isFunction(element.nativeElement.scrollIntoView)) {\n      element.nativeElement.scrollIntoView({ block: 'center', behavior });\n    }\n  }\n\n  protected abstract handleQueryListOption(options: QueryList<OptionControl<T>>): void;\n\n  protected abstract handleSearchFieldChanges(): void;\n\n  protected abstract activateSelectedOption(): void;\n\n  protected initKeyManager(options: QueryList<OptionControl<T>>): void {\n    this.keyManager = new ActiveDescendantKeyManager(options).withHomeAndEnd();\n  }\n\n  protected disableSmoothScroll(): void {\n    this.smoothScrollEnabled = false;\n  }\n\n  protected enableSmoothScroll(): void {\n    this.smoothScrollEnabled = true;\n  }\n\n  protected openDropdown(): void {\n    this.dropdown?.open();\n  }\n\n  protected closeDropdown(): void {\n    this.dropdown?.close();\n  }\n\n  @HostListener('focusout', ['$event'])\n  protected handleFocusOut(event: FocusEvent): void {\n    if (this.isOpen) {\n      event.stopImmediatePropagation();\n    }\n    this.onTouched();\n  }\n}\n"]}

package/esm2022/cdk/checkbox-control/lib/checkbox-control.directive.mjs

@@ -3,6 +3,9 @@ import { detectControllerChanges } from '@odx/angular';
 import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
 import { booleanToAttributeString, injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * `CheckBoxControl` is a directive that extends `CustomFormControl` to create a custom checkbox control. It integrates seamlessly with Angular forms and provides additional events and bindings for enhanced functionality.
+ */
 export class CheckBoxControl extends CustomFormControl {
     set checked(value) {
         this.value = value;
@@ -43,4 +46,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], checkedChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/connected-overlay/lib/connected-overlay.service.mjs

@@ -4,10 +4,54 @@ import { deepmerge } from '@odx/angular/internal';
 import { ConnectedOverlayComponent } from './connected-overlay.component';
 import { ConnectedOverlayRef, DefaultConnectedOverlayOptions } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Service for creating and managing connected overlays. These overlays are UI elements such as popovers, tooltips,
+ * or dropdown menus that are positioned relative to a reference element in the DOM. This service leverages the `DynamicViewService`
+ * for dynamic component rendering and provides a streamlined API for creating overlays with custom positioning and options.
+ *
+ * Use the `ConnectedOverlayService` to dynamically create an overlay next to a specific element in your Angular application.
+ * This example demonstrates creating a connected overlay next to a button element when the button is clicked.
+ *
+ * @example
+ * ```ts
+ * import { Component, ElementRef, ViewChild } from '@angular/core';
+ * import { ConnectedOverlayService, ConnectedOverlayOptions } from '@odx/angular/cdk/connected-overlay';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: `<button #triggerElement>Click me</button>`,
+ * })
+ * class AppComponent {
+ *   @ViewChild('triggerElement') triggerElementRef!: ElementRef;
+ *
+ *   constructor(private connectedOverlayService: ConnectedOverlayService) {}
+ *
+ *   showOverlay(): void {
+ *     const options: Partial<ConnectedOverlayOptions> = {
+ *       position: 'bottom-start',
+ *       showArrow: true,
+ *       content: 'Hello, world!',
+ *     };
+ *
+ *     this.connectedOverlayService.createOverlay(this.triggerElementRef.nativeElement, options);
+ *   }
+ * }
+ * ```
+ *
+ * This service simplifies the process of creating dynamic, positionally aware overlays that enhance the interactivity
+ * and visual appeal of Angular applications.
+ */
 export class ConnectedOverlayService {
     constructor() {
         this.dynamicViewService = inject(DynamicViewService);
     }
+    /**
+     * Creates a connected overlay.
+     * @param referenceElement - The reference element to which the overlay will be connected.
+     * @param options - Optional configuration for the connected overlay.
+     * @param renderingOptions - Optional rendering options for the connected overlay.
+     * @returns {ConnectedOverlayRef} The created Connected Overlay reference instance.
+     */
     createOverlay(referenceElement, options, renderingOptions) {
         const dynamicViewRef = this.dynamicViewService.createView(ConnectedOverlayComponent, {
             ...renderingOptions,
@@ -22,4 +66,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/cdk/connected-overlay/lib/helpers/compute-overlay-position.mjs

@@ -1,5 +1,15 @@
 import { arrow, computePosition, flip, hide, shift, size, offset as withOffset } from '@floating-ui/dom';
 import { applyStyles, cssTranslate, getOppositeSide, getSide, px } from '@odx/angular/utils';
+/**
+ * Computes the position of an overlay element relative to a reference element.
+ *
+ * @param referenceElement - The reference element to position the overlay relative to.
+ * @param overlayElement - The overlay element to be positioned.
+ * @param contentElement - The content element within the overlay.
+ * @param arrowElement - The arrow element within the overlay.
+ * @param options - The options for positioning the overlay.
+ * @returns A promise that resolves to the computed position of the overlay.
+ */
 export async function computeOverlayPosition(referenceElement, overlayElement, contentElement, arrowElement, options) {
     const { position, offset, outerPadding, matchReferenceWidth, enableFallback, fallbackAxisSideDirection, strategy, minHeight } = options;
     const arrowSize = options.showArrow ? arrowElement.offsetWidth : 0;
@@ -51,4 +61,4 @@ export async function computeOverlayPosition(referenceElement, overlayElement, c
         return result;
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute-overlay-position.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/cdk/connected-overlay/src/lib/helpers/compute-overlay-position.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComputePositionReturn, VirtualElement, arrow, computePosition, flip, hide, shift, size, offset as withOffset } from '@floating-ui/dom';\nimport { applyStyles, cssTranslate, getOppositeSide, getSide, px } from '@odx/angular/utils';\nimport { ConnectedOverlayOptions } from '../models';\n\n/**\n * Computes the position of an overlay element relative to a reference element.\n *\n * @param referenceElement - The reference element to position the overlay relative to.\n * @param overlayElement - The overlay element to be positioned.\n * @param contentElement - The content element within the overlay.\n * @param arrowElement - The arrow element within the overlay.\n * @param options - The options for positioning the overlay.\n * @returns A promise that resolves to the computed position of the overlay.\n */\nexport async function computeOverlayPosition(\n  referenceElement: VirtualElement,\n  overlayElement: HTMLElement,\n  contentElement: HTMLElement,\n  arrowElement: HTMLElement,\n  options: ConnectedOverlayOptions,\n): Promise<ComputePositionReturn> {\n  const { position, offset, outerPadding, matchReferenceWidth, enableFallback, fallbackAxisSideDirection, strategy, minHeight } = options;\n  const arrowSize = options.showArrow ? arrowElement.offsetWidth : 0;\n  const arrowMiddleware = options.showArrow ? [arrow({ element: arrowElement, padding: 8 })] : [];\n  const flipMiddleWare = enableFallback ? [flip({ fallbackAxisSideDirection })] : [];\n\n  return computePosition(referenceElement, overlayElement, {\n    strategy,\n    placement: position,\n    middleware: [\n      withOffset(Math.max(offset, arrowSize + offset)),\n      shift({ padding: outerPadding }),\n      ...flipMiddleWare,\n      size({\n        padding: outerPadding,\n        apply: ({ availableHeight, availableWidth, rects }) => {\n          const variablePrefix = '--odx-cdk-connected-overlay';\n          contentElement.style.setProperty(`${variablePrefix}-max-height`, px(availableHeight));\n          contentElement.style.setProperty(`${variablePrefix}-max-width`, px(availableWidth));\n          contentElement.style.setProperty(`${variablePrefix}-min-height`, minHeight ? px(Math.min(availableHeight, minHeight)) : null);\n          contentElement.style.setProperty(`${variablePrefix}-min-width`, matchReferenceWidth ? px(rects.reference.width) : null);\n        },\n      }),\n      ...arrowMiddleware,\n      hide(),\n    ],\n  }).then((result) => {\n    applyStyles(overlayElement, {\n      top: '0',\n      left: '0',\n      transform: cssTranslate(px(result.x), px(result.y)),\n    });\n    if (options.hiddenClass) {\n      overlayElement.classList.toggle(options.hiddenClass, !!result.middlewareData.hide?.referenceHidden);\n    }\n    if (options.showArrow) {\n      const overlaySide = getSide(result.placement);\n      const arrowSide = getOppositeSide(result.placement);\n      applyStyles(arrowElement, {\n        display: null,\n        top: px(result.middlewareData.arrow?.y),\n        left: px(result.middlewareData.arrow?.x),\n        [arrowSide]: px(-arrowSize / 2),\n        [overlaySide]: null,\n      });\n    } else {\n      applyStyles(arrowElement, { display: 'none' });\n    }\n\n    return result;\n  });\n}\n"]}

package/esm2022/cdk/connected-overlay/lib/models/connected-overlay-ref.mjs

@@ -1,15 +1,64 @@
 import { EMPTY } from 'rxjs';
+/**
+ * A reference to a connected overlay created by the `ConnectedOverlayService`. This class provides methods to interact
+ * with the overlay, such as updating its options or closing it. It encapsulates the `DynamicViewRef` for the overlay's instance,
+ * allowing for direct manipulation of the overlay's state and behavior.
+ *
+ * This example demonstrates how to use a `ConnectedOverlayRef` to update and close a connected overlay in response
+ * to user interactions.
+ *
+ * @example
+ * ```ts
+ * class MyComponent {
+ *   private overlayRef?: ConnectedOverlayRef;
+ *
+ *   constructor(private overlayService: ConnectedOverlayService) {}
+ *
+ *   openOverlay() {
+ *     this.overlayRef = this.overlayService.createOverlay(this.someElementRef.nativeElement, { position: 'bottom' });
+ *   }
+ *
+ *   updateOverlayPosition() {
+ *     if (this.overlayRef) {
+ *       this.overlayRef.update({ position: 'top' });
+ *     }
+ *   }
+ *
+ *   closeOverlay() {
+ *     this.overlayRef?.close();
+ *   }
+ * }
+ * ```
+ *
+ * In this example, `MyComponent` uses the `ConnectedOverlayService` to create an overlay. It stores a reference to
+ * the created overlay in `overlayRef`, allowing it to update the overlay's position or close it when necessary.
+ */
 export class ConnectedOverlayRef {
     constructor(dynamicViewRef) {
         this.dynamicViewRef = dynamicViewRef;
         this.element = this.dynamicViewRef.getElement();
+        /**
+         * An Observable that emits when the overlay is closed.
+         *
+         * @emits {void} - Emits when the overlay is closed.
+         */
         this.onClose$ = this.dynamicViewRef.getContext().closed ?? EMPTY;
     }
+    /**
+     * Updates the connected overlay with new options.
+     *
+     * @param options - The new options to be applied to the connected overlay.
+     */
     update(options) {
         this.dynamicViewRef.update({ options: options });
     }
+    /**
+     * Closes the connected overlay.
+     *
+     * @returns {void}
+     */
     close() {
         this.dynamicViewRef.destroy();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGVkLW92ZXJsYXktcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9jb25uZWN0ZWQtb3ZlcmxheS9zcmMvbGliL21vZGVscy9jb25uZWN0ZWQtb3ZlcmxheS1yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUl6QyxNQUFNLE9BQU8sbUJBQW1CO0lBSTlCLFlBQTZCLGNBQWdFO1FBQWhFLG1CQUFjLEdBQWQsY0FBYyxDQUFrRDtRQUg3RSxZQUFPLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUMzQyxhQUFRLEdBQXFCLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQztJQUVFLENBQUM7SUFFMUYsTUFBTSxDQUFDLE9BQXlDO1FBQ3JELElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQWtDLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEeW5hbWljVmlld1JlZiB9IGZyb20gJ0BvZHgvYW5ndWxhci9jZGsvZHluYW1pYy12aWV3JztcbmltcG9ydCB7IEVNUFRZLCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDb25uZWN0ZWRPdmVybGF5Q29tcG9uZW50IH0gZnJvbSAnLi4vY29ubmVjdGVkLW92ZXJsYXkuY29tcG9uZW50JztcbmltcG9ydCB7IENvbm5lY3RlZE92ZXJsYXlPcHRpb25zIH0gZnJvbSAnLi9jb25uZWN0ZWQtb3ZlcmxheS1vcHRpb25zJztcblxuZXhwb3J0IGNsYXNzIENvbm5lY3RlZE92ZXJsYXlSZWYge1xuICBwdWJsaWMgcmVhZG9ubHkgZWxlbWVudCA9IHRoaXMuZHluYW1pY1ZpZXdSZWYuZ2V0RWxlbWVudCgpO1xuICBwdWJsaWMgcmVhZG9ubHkgb25DbG9zZSQ6IE9ic2VydmFibGU8dm9pZD4gPSB0aGlzLmR5bmFtaWNWaWV3UmVmLmdldENvbnRleHQoKS5jbG9zZWQgPz8gRU1QVFk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBkeW5hbWljVmlld1JlZjogRHluYW1pY1ZpZXdSZWY8dHlwZW9mIENvbm5lY3RlZE92ZXJsYXlDb21wb25lbnQ+KSB7fVxuXG4gIHB1YmxpYyB1cGRhdGUob3B0aW9uczogUGFydGlhbDxDb25uZWN0ZWRPdmVybGF5T3B0aW9ucz4pIHtcbiAgICB0aGlzLmR5bmFtaWNWaWV3UmVmLnVwZGF0ZSh7IG9wdGlvbnM6IG9wdGlvbnMgYXMgQ29ubmVjdGVkT3ZlcmxheU9wdGlvbnMgfSk7XG4gIH1cblxuICBwdWJsaWMgY2xvc2UoKTogdm9pZCB7XG4gICAgdGhpcy5keW5hbWljVmlld1JlZi5kZXN0cm95KCk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGVkLW92ZXJsYXktcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9jb25uZWN0ZWQtb3ZlcmxheS9zcmMvbGliL21vZGVscy9jb25uZWN0ZWQtb3ZlcmxheS1yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUl6Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUNHO0FBQ0gsTUFBTSxPQUFPLG1CQUFtQjtJQVU5QixZQUE2QixjQUFnRTtRQUFoRSxtQkFBYyxHQUFkLGNBQWMsQ0FBa0Q7UUFUN0UsWUFBTyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUM7UUFFM0Q7Ozs7V0FJRztRQUNhLGFBQVEsR0FBcUIsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxNQUFNLElBQUksS0FBSyxDQUFDO0lBRUUsQ0FBQztJQUVqRzs7OztPQUlHO0lBQ0ksTUFBTSxDQUFDLE9BQXlDO1FBQ3JELElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQWtDLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksS0FBSztRQUNWLElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDaEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRHluYW1pY1ZpZXdSZWYgfSBmcm9tICdAb2R4L2FuZ3VsYXIvY2RrL2R5bmFtaWMtdmlldyc7XG5pbXBvcnQgeyBFTVBUWSwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgQ29ubmVjdGVkT3ZlcmxheUNvbXBvbmVudCB9IGZyb20gJy4uL2Nvbm5lY3RlZC1vdmVybGF5LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDb25uZWN0ZWRPdmVybGF5T3B0aW9ucyB9IGZyb20gJy4vY29ubmVjdGVkLW92ZXJsYXktb3B0aW9ucyc7XG5cbi8qKlxuICogQSByZWZlcmVuY2UgdG8gYSBjb25uZWN0ZWQgb3ZlcmxheSBjcmVhdGVkIGJ5IHRoZSBgQ29ubmVjdGVkT3ZlcmxheVNlcnZpY2VgLiBUaGlzIGNsYXNzIHByb3ZpZGVzIG1ldGhvZHMgdG8gaW50ZXJhY3RcbiAqIHdpdGggdGhlIG92ZXJsYXksIHN1Y2ggYXMgdXBkYXRpbmcgaXRzIG9wdGlvbnMgb3IgY2xvc2luZyBpdC4gSXQgZW5jYXBzdWxhdGVzIHRoZSBgRHluYW1pY1ZpZXdSZWZgIGZvciB0aGUgb3ZlcmxheSdzIGluc3RhbmNlLFxuICogYWxsb3dpbmcgZm9yIGRpcmVjdCBtYW5pcHVsYXRpb24gb2YgdGhlIG92ZXJsYXkncyBzdGF0ZSBhbmQgYmVoYXZpb3IuXG4gKlxuICogVGhpcyBleGFtcGxlIGRlbW9uc3RyYXRlcyBob3cgdG8gdXNlIGEgYENvbm5lY3RlZE92ZXJsYXlSZWZgIHRvIHVwZGF0ZSBhbmQgY2xvc2UgYSBjb25uZWN0ZWQgb3ZlcmxheSBpbiByZXNwb25zZVxuICogdG8gdXNlciBpbnRlcmFjdGlvbnMuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiBjbGFzcyBNeUNvbXBvbmVudCB7XG4gKiAgIHByaXZhdGUgb3ZlcmxheVJlZj86IENvbm5lY3RlZE92ZXJsYXlSZWY7XG4gKlxuICogICBjb25zdHJ1Y3Rvcihwcml2YXRlIG92ZXJsYXlTZXJ2aWNlOiBDb25uZWN0ZWRPdmVybGF5U2VydmljZSkge31cbiAqXG4gKiAgIG9wZW5PdmVybGF5KCkge1xuICogICAgIHRoaXMub3ZlcmxheVJlZiA9IHRoaXMub3ZlcmxheVNlcnZpY2UuY3JlYXRlT3ZlcmxheSh0aGlzLnNvbWVFbGVtZW50UmVmLm5hdGl2ZUVsZW1lbnQsIHsgcG9zaXRpb246ICdib3R0b20nIH0pO1xuICogICB9XG4gKlxuICogICB1cGRhdGVPdmVybGF5UG9zaXRpb24oKSB7XG4gKiAgICAgaWYgKHRoaXMub3ZlcmxheVJlZikge1xuICogICAgICAgdGhpcy5vdmVybGF5UmVmLnVwZGF0ZSh7IHBvc2l0aW9uOiAndG9wJyB9KTtcbiAqICAgICB9XG4gKiAgIH1cbiAqXG4gKiAgIGNsb3NlT3ZlcmxheSgpIHtcbiAqICAgICB0aGlzLm92ZXJsYXlSZWY/LmNsb3NlKCk7XG4gKiAgIH1cbiAqIH1cbiAqIGBgYFxuICpcbiAqIEluIHRoaXMgZXhhbXBsZSwgYE15Q29tcG9uZW50YCB1c2VzIHRoZSBgQ29ubmVjdGVkT3ZlcmxheVNlcnZpY2VgIHRvIGNyZWF0ZSBhbiBvdmVybGF5LiBJdCBzdG9yZXMgYSByZWZlcmVuY2UgdG9cbiAqIHRoZSBjcmVhdGVkIG92ZXJsYXkgaW4gYG92ZXJsYXlSZWZgLCBhbGxvd2luZyBpdCB0byB1cGRhdGUgdGhlIG92ZXJsYXkncyBwb3NpdGlvbiBvciBjbG9zZSBpdCB3aGVuIG5lY2Vzc2FyeS5cbiAqL1xuZXhwb3J0IGNsYXNzIENvbm5lY3RlZE92ZXJsYXlSZWYge1xuICBwdWJsaWMgcmVhZG9ubHkgZWxlbWVudCA9IHRoaXMuZHluYW1pY1ZpZXdSZWYuZ2V0RWxlbWVudCgpO1xuXG4gIC8qKlxuICAgKiBBbiBPYnNlcnZhYmxlIHRoYXQgZW1pdHMgd2hlbiB0aGUgb3ZlcmxheSBpcyBjbG9zZWQuXG4gICAqXG4gICAqIEBlbWl0cyB7dm9pZH0gLSBFbWl0cyB3aGVuIHRoZSBvdmVybGF5IGlzIGNsb3NlZC5cbiAgICovXG4gIHB1YmxpYyByZWFkb25seSBvbkNsb3NlJDogT2JzZXJ2YWJsZTx2b2lkPiA9IHRoaXMuZHluYW1pY1ZpZXdSZWYuZ2V0Q29udGV4dCgpLmNsb3NlZCA/PyBFTVBUWTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGR5bmFtaWNWaWV3UmVmOiBEeW5hbWljVmlld1JlZjx0eXBlb2YgQ29ubmVjdGVkT3ZlcmxheUNvbXBvbmVudD4pIHt9XG5cbiAgLyoqXG4gICAqIFVwZGF0ZXMgdGhlIGNvbm5lY3RlZCBvdmVybGF5IHdpdGggbmV3IG9wdGlvbnMuXG4gICAqXG4gICAqIEBwYXJhbSBvcHRpb25zIC0gVGhlIG5ldyBvcHRpb25zIHRvIGJlIGFwcGxpZWQgdG8gdGhlIGNvbm5lY3RlZCBvdmVybGF5LlxuICAgKi9cbiAgcHVibGljIHVwZGF0ZShvcHRpb25zOiBQYXJ0aWFsPENvbm5lY3RlZE92ZXJsYXlPcHRpb25zPik6IHZvaWQge1xuICAgIHRoaXMuZHluYW1pY1ZpZXdSZWYudXBkYXRlKHsgb3B0aW9uczogb3B0aW9ucyBhcyBDb25uZWN0ZWRPdmVybGF5T3B0aW9ucyB9KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDbG9zZXMgdGhlIGNvbm5lY3RlZCBvdmVybGF5LlxuICAgKlxuICAgKiBAcmV0dXJucyB7dm9pZH1cbiAgICovXG4gIHB1YmxpYyBjbG9zZSgpOiB2b2lkIHtcbiAgICB0aGlzLmR5bmFtaWNWaWV3UmVmLmRlc3Ryb3koKTtcbiAgfVxufVxuIl19