@odx/angular 2.16.1 → 3.0.0

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

@@ -0,0 +1,34 @@
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { inject, Injectable } from '@angular/core';
+import { distinctUntilChanged, map, of, shareReplay } from 'rxjs';
+import { injectBreakpointsConfig } from './breakpoints.config';
+import * as i0 from "@angular/core";
+export class BreakpointsService {
+    constructor() {
+        this.breakpointObserver = inject(BreakpointObserver);
+        this.config = injectBreakpointsConfig();
+    }
+    observe(breakpoints) {
+        const mediaQueries = this.getMediaQueries(breakpoints);
+        return this.createBreakpointObserver(mediaQueries);
+    }
+    matches(breakpoints) {
+        const mediaQueries = this.getMediaQueries(breakpoints);
+        return this.breakpointObserver.isMatched(mediaQueries);
+    }
+    getMediaQueries(breakpointNames) {
+        return breakpointNames.map((name) => this.config.breakpoints[name]).filter(Boolean);
+    }
+    createBreakpointObserver(mediaQueries) {
+        if (mediaQueries.length < 1)
+            return of(false);
+        return this.breakpointObserver.observe(mediaQueries).pipe(map(({ matches }) => matches), distinctUntilChanged(), shareReplay({ refCount: true }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,47 @@
+import { Directive, inject, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { coerceArray, untilDestroyed } from '@odx/angular/utils';
+import { BehaviorSubject, switchMap, tap } from 'rxjs';
+import { BreakpointsService } from '../breakpoints.service';
+import * as i0 from "@angular/core";
+export class MatchBreakpointsDirective {
+    constructor() {
+        this.breakpoints$$ = new BehaviorSubject([]);
+        this.breakpointsService = inject(BreakpointsService);
+        this.takeUntilDestroyed = untilDestroyed();
+        this.template = inject(TemplateRef);
+        this.viewContainer = inject(ViewContainerRef);
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.elseTemplate = null;
+    }
+    set breakpoints(value) {
+        this.breakpoints$$.next(coerceArray(value ?? []));
+    }
+    ngOnInit() {
+        this.breakpoints$$
+            .pipe(switchMap((breakpoints) => this.breakpointsService.observe(breakpoints)), tap((matchesBreakpoints) => this.render(matchesBreakpoints)), this.takeUntilDestroyed())
+            .subscribe();
+    }
+    render(matchesBreakpoints) {
+        this.viewContainer.clear();
+        const template = matchesBreakpoints ? this.template : this.elseTemplate;
+        if (template) {
+            this.viewContainer.createEmbeddedView(template);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatchBreakpointsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: MatchBreakpointsDirective, isStandalone: true, selector: "ng-template[odxMatchBreakpoints]", inputs: { breakpoints: ["odxMatchBreakpoints", "breakpoints"], elseTemplate: ["odxMatchBreakpointsElse", "elseTemplate"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatchBreakpointsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'ng-template[odxMatchBreakpoints]',
+                }]
+        }], propDecorators: { breakpoints: [{
+                type: Input,
+                args: ['odxMatchBreakpoints']
+            }], elseTemplate: [{
+                type: Input,
+                args: ['odxMatchBreakpointsElse']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/a11y/lib/a11y.module.mjs

@@ -0,0 +1,19 @@
+import { A11yModule as NgCdkA11yModule } from '@angular/cdk/a11y';
+import { NgModule } from '@angular/core';
+import { CoreModule } from '@odx/angular';
+import { InteractiveDirective, ListFocusManagerDirective, ListFocusManagerOptionDirective } from './directives';
+import * as i0 from "@angular/core";
+const modules = [ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective];
+export class A11yModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, imports: [NgCdkA11yModule, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective], exports: [CoreModule, NgCdkA11yModule, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, imports: [NgCdkA11yModule, CoreModule, NgCdkA11yModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [NgCdkA11yModule, ...modules],
+                    exports: [CoreModule, NgCdkA11yModule, ...modules],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYTExeS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2ExMXkvc3JjL2xpYi9hMTF5Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxJQUFJLGVBQWUsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMxQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUseUJBQXlCLEVBQUUsK0JBQStCLEVBQUUsTUFBTSxjQUFjLENBQUM7O0FBRWhILE1BQU0sT0FBTyxHQUFHLENBQUMseUJBQXlCLEVBQUUsK0JBQStCLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztBQU1uRyxNQUFNLE9BQU8sVUFBVTsrR0FBVixVQUFVO2dIQUFWLFVBQVUsWUFIWCxlQUFlLEVBSFYseUJBQXlCLEVBQUUsK0JBQStCLEVBQUUsb0JBQW9CLGFBSXJGLFVBQVUsRUFBRSxlQUFlLEVBSnRCLHlCQUF5QixFQUFFLCtCQUErQixFQUFFLG9CQUFvQjtnSEFNcEYsVUFBVSxZQUhYLGVBQWUsRUFDZixVQUFVLEVBQUUsZUFBZTs7NEZBRTFCLFVBQVU7a0JBSnRCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsZUFBZSxFQUFFLEdBQUcsT0FBTyxDQUFDO29CQUN0QyxPQUFPLEVBQUUsQ0FBQyxVQUFVLEVBQUUsZUFBZSxFQUFFLEdBQUcsT0FBTyxDQUFDO2lCQUNuRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEExMXlNb2R1bGUgYXMgTmdDZGtBMTF5TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvcmVNb2R1bGUgfSBmcm9tICdAb2R4L2FuZ3VsYXInO1xuaW1wb3J0IHsgSW50ZXJhY3RpdmVEaXJlY3RpdmUsIExpc3RGb2N1c01hbmFnZXJEaXJlY3RpdmUsIExpc3RGb2N1c01hbmFnZXJPcHRpb25EaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMnO1xuXG5jb25zdCBtb2R1bGVzID0gW0xpc3RGb2N1c01hbmFnZXJEaXJlY3RpdmUsIExpc3RGb2N1c01hbmFnZXJPcHRpb25EaXJlY3RpdmUsIEludGVyYWN0aXZlRGlyZWN0aXZlXTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW05nQ2RrQTExeU1vZHVsZSwgLi4ubW9kdWxlc10sXG4gIGV4cG9ydHM6IFtDb3JlTW9kdWxlLCBOZ0Nka0ExMXlNb2R1bGUsIC4uLm1vZHVsZXNdLFxufSlcbmV4cG9ydCBjbGFzcyBBMTF5TW9kdWxlIHt9XG4iXX0=

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

@@ -0,0 +1,48 @@
+import { __decorate } from "tslib";
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+import { DisabledController, WithDisabledState, WithTabIndex } from '@odx/angular';
+import { CSSComponent } from '@odx/angular/internal';
+import { injectElement } from '@odx/angular/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@odx/angular";
+export let InteractiveDirective = class InteractiveDirective {
+    constructor() {
+        this.disabledController = DisabledController.inject();
+        this.element = injectElement();
+        this.interact = new EventEmitter();
+    }
+    handleEvents(event) {
+        if (!this.disabledController?.disabled) {
+            this.interact.next(event);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InteractiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: InteractiveDirective, isStandalone: true, selector: "[odxCdkInteractive]", outputs: { interact: "odxCdkInteractive" }, host: { attributes: { "role": "button" }, listeners: { "click": "handleEvents($event)", "keyup.enter": "handleEvents($event)", "keyup.space": "handleEvents($event)" } }, hostDirectives: [{ directive: i1.WithDisabledState }, { directive: i1.WithTabIndex }], ngImport: i0 }); }
+};
+InteractiveDirective = __decorate([
+    CSSComponent('cdk-interactive')
+], InteractiveDirective);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InteractiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[odxCdkInteractive]',
+                    standalone: true,
+                    hostDirectives: [WithDisabledState, WithTabIndex],
+                    host: {
+                        role: 'button',
+                    },
+                }]
+        }], propDecorators: { interact: [{
+                type: Output,
+                args: ['odxCdkInteractive']
+            }], handleEvents: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keyup.enter', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keyup.space', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+import { Directive } from '@angular/core';
+import { DisabledController } from '@odx/angular';
+import { injectElement } from '@odx/angular/utils';
+import * as i0 from "@angular/core";
+export class ListFocusManagerOptionDirective {
+    constructor() {
+        this.disabledController = DisabledController.inject();
+        this.element = injectElement();
+    }
+    get disabled() {
+        return !!this.disabledController?.disabled;
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerOptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ListFocusManagerOptionDirective, isStandalone: true, selector: "[odxListFocusManager]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerOptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[odxListFocusManager]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1mb2N1cy1tYW5hZ2VyLW9wdGlvbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2ExMXkvc3JjL2xpYi9kaXJlY3RpdmVzL2xpc3QtZm9jdXMtbWFuYWdlci1vcHRpb24uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDMUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2xELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFNbkQsTUFBTSxPQUFPLCtCQUErQjtJQUo1QztRQUttQix1QkFBa0IsR0FBRyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNqRCxZQUFPLEdBQUcsYUFBYSxFQUFFLENBQUM7S0FTNUM7SUFQQyxJQUFXLFFBQVE7UUFDakIsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLGtCQUFrQixFQUFFLFFBQVEsQ0FBQztJQUM3QyxDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JDLENBQUM7K0dBVlUsK0JBQStCO21HQUEvQiwrQkFBK0I7OzRGQUEvQiwrQkFBK0I7a0JBSjNDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHVCQUF1QjtvQkFDakMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9jdXNhYmxlT3B0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuaW1wb3J0IHsgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEaXNhYmxlZENvbnRyb2xsZXIgfSBmcm9tICdAb2R4L2FuZ3VsYXInO1xuaW1wb3J0IHsgaW5qZWN0RWxlbWVudCB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tvZHhMaXN0Rm9jdXNNYW5hZ2VyXScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIExpc3RGb2N1c01hbmFnZXJPcHRpb25EaXJlY3RpdmUgaW1wbGVtZW50cyBGb2N1c2FibGVPcHRpb24ge1xuICBwcml2YXRlIHJlYWRvbmx5IGRpc2FibGVkQ29udHJvbGxlciA9IERpc2FibGVkQ29udHJvbGxlci5pbmplY3QoKTtcbiAgcHJpdmF0ZSByZWFkb25seSBlbGVtZW50ID0gaW5qZWN0RWxlbWVudCgpO1xuXG4gIHB1YmxpYyBnZXQgZGlzYWJsZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuICEhdGhpcy5kaXNhYmxlZENvbnRyb2xsZXI/LmRpc2FibGVkO1xuICB9XG5cbiAgcHVibGljIGZvY3VzKCk6IHZvaWQge1xuICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZvY3VzKCk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,40 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { ContentChildren, Directive, HostListener, QueryList } from '@angular/core';
+import { deferFn } from '@odx/angular/utils';
+import { ListFocusManagerOptionDirective } from './list-focus-manager-option.directive';
+import * as i0 from "@angular/core";
+export class ListFocusManagerDirective {
+    constructor() {
+        this.keyManager = null;
+    }
+    ngAfterContentInit() {
+        this.keyManager = new FocusKeyManager(this.options)
+            .withHomeAndEnd()
+            .withWrap()
+            .skipPredicate((item) => item.disabled);
+        deferFn(() => this.keyManager?.setFirstItemActive());
+    }
+    ngOnDestroy() {
+        this.keyManager?.destroy();
+        this.keyManager = null;
+    }
+    onKeyDown(event) {
+        this.keyManager?.onKeydown(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ListFocusManagerDirective, isStandalone: true, selector: "[odxListFocusManager]", host: { listeners: { "keydown": "onKeyDown($event)" } }, queries: [{ propertyName: "options", predicate: ListFocusManagerOptionDirective }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[odxListFocusManager]',
+                    standalone: true,
+                }]
+        }], propDecorators: { options: [{
+                type: ContentChildren,
+                args: [ListFocusManagerOptionDirective]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,127 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input } from '@angular/core';
+import { CSSComponent, CSSModifier } from '@odx/angular/internal';
+import { fromElementResize$ } from '@odx/angular/rxjs';
+import { applyStyles, disableCSSTransitions, hasChanged, injectElement, isPresent, px, untilDestroyed } from '@odx/angular/utils';
+import { BehaviorSubject, distinctUntilChanged, EMPTY, switchMap } from 'rxjs';
+import { ActiveIndicatorPosition } from './models';
+import { ActiveIndicatorDirection } from './models/active-indicator-direction';
+import * as i0 from "@angular/core";
+export let ActiveIndicatorDirective = class ActiveIndicatorDirective {
+    constructor() {
+        this.takeUntilDestroyed = untilDestroyed();
+        this.parentElement$$ = new BehaviorSubject(null);
+        this.onResize$ = this.parentElement$$.pipe(distinctUntilChanged(), switchMap((parentElement) => {
+            return parentElement ? fromElementResize$(parentElement) : EMPTY;
+        }));
+        this.element = injectElement();
+        this.isActive = false;
+        this.activeElement = null;
+        this.direction = ActiveIndicatorDirection.HORIZONTAL;
+        this.position = ActiveIndicatorPosition.CENTER;
+    }
+    set parent(value) {
+        this.parentElement$$.next(value);
+    }
+    get parent() {
+        return this.parentElement$$.getValue();
+    }
+    ngAfterViewInit() {
+        this.onResize$.pipe(this.takeUntilDestroyed()).subscribe(() => this.updateStyles());
+        this.parent ??= this.element.nativeElement.parentElement;
+    }
+    ngOnChanges(changes) {
+        if (hasChanged(changes, 'activeElement', false)) {
+            this.isActive = !!this.activeElement;
+        }
+        if (hasChanged(changes, ['activeElement', 'direction', 'position'])) {
+            this.updateStyles(!isPresent(changes.activeElement?.previousValue));
+        }
+    }
+    updateStyles(disableTransition = false) {
+        if (!this.activeElement)
+            return;
+        const isHorizontal = this.direction === ActiveIndicatorDirection.HORIZONTAL;
+        const isVertical = this.direction === ActiveIndicatorDirection.VERTICAL;
+        const relativeOffset = this.getIndicatorRelativeOffset();
+        let transform = null;
+        if (isHorizontal) {
+            const positionX = this.getIndicatorPositionX(this.activeElement);
+            transform = `translateX(${px(positionX)}) translateX(${relativeOffset}%)`;
+        }
+        if (isVertical) {
+            const positionY = this.getIndicatorPositionY(this.activeElement);
+            transform = `translateY(${px(positionY)}) translateY(${relativeOffset}%)`;
+        }
+        disableTransition && disableCSSTransitions(this.element.nativeElement, true);
+        applyStyles(this.element.nativeElement, {
+            transform,
+            width: isHorizontal ? px(this.activeElement.offsetWidth) : null,
+            height: isVertical ? px(this.activeElement.offsetHeight) : null,
+        });
+        disableTransition && disableCSSTransitions(this.element.nativeElement, false);
+    }
+    getIndicatorPositionX(activeElement) {
+        switch (this.position) {
+            case ActiveIndicatorPosition.START:
+                return activeElement.offsetLeft;
+            case ActiveIndicatorPosition.CENTER:
+                return activeElement.offsetLeft + activeElement.offsetWidth / 2;
+            case ActiveIndicatorPosition.END:
+                return activeElement.offsetLeft + activeElement.offsetWidth;
+        }
+    }
+    getIndicatorPositionY(activeElement) {
+        switch (this.position) {
+            case ActiveIndicatorPosition.START:
+                return activeElement.offsetTop;
+            case ActiveIndicatorPosition.CENTER:
+                return activeElement.offsetTop + activeElement.offsetHeight / 2;
+            case ActiveIndicatorPosition.END:
+                return activeElement.offsetTop + activeElement.offsetHeight;
+        }
+    }
+    getIndicatorRelativeOffset() {
+        switch (this.position) {
+            case ActiveIndicatorPosition.START:
+                return 0;
+            case ActiveIndicatorPosition.CENTER:
+                return -50;
+            case ActiveIndicatorPosition.END:
+                return -100;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ActiveIndicatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ActiveIndicatorDirective, isStandalone: true, selector: "[odxActiveIndicator]", inputs: { activeElement: ["odxActiveIndicator", "activeElement"], parent: ["odxActiveIndicatorParent", "parent"], direction: ["odxActiveIndicatorDirection", "direction"], position: ["odxActiveIndicatorPosition", "position"] }, usesOnChanges: true, ngImport: i0 }); }
+};
+__decorate([
+    CSSModifier(),
+    __metadata("design:type", Object)
+], ActiveIndicatorDirective.prototype, "isActive", void 0);
+__decorate([
+    CSSModifier(),
+    __metadata("design:type", String)
+], ActiveIndicatorDirective.prototype, "direction", void 0);
+ActiveIndicatorDirective = __decorate([
+    CSSComponent('cdk-active-indicator')
+], ActiveIndicatorDirective);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ActiveIndicatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[odxActiveIndicator]',
+                }]
+        }], propDecorators: { isActive: [], activeElement: [{
+                type: Input,
+                args: ['odxActiveIndicator']
+            }], parent: [{
+                type: Input,
+                args: ['odxActiveIndicatorParent']
+            }], direction: [{
+                type: Input,
+                args: ['odxActiveIndicatorDirection']
+            }], position: [{
+                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":";AAAA,OAAO,EAAiB,SAAS,EAAE,KAAK,EAAa,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAa,EAAE,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC7I,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;;AAOxE,WAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IAA9B;QACY,uBAAkB,GAAG,cAAc,EAAE,CAAC;QACtC,oBAAe,GAAG,IAAI,eAAe,CAAqB,IAAI,CAAC,CAAC;QAChE,cAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CACpD,oBAAoB,EAAE,EACtB,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE;YAC1B,OAAO,aAAa,CAAC,CAAC,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACnE,CAAC,CAAC,CACH,CAAC;QAEc,YAAO,GAAG,aAAa,EAAE,CAAC;QAGnC,aAAQ,GAAG,KAAK,CAAC;QAGjB,kBAAa,GAAwB,IAAI,CAAC;QAY1C,cAAS,GAA6B,wBAAwB,CAAC,UAAU,CAAC;QAG1E,aAAQ,GAA4B,uBAAuB,CAAC,MAAM,CAAC;KAyE3E;IAtFC,IACW,MAAM,CAAC,KAAyB;QACzC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IACD,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;IACzC,CAAC;IASM,eAAe;QACpB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;QACpF,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC;IAC3D,CAAC;IAEM,WAAW,CAAC,OAA4C;QAC7D,IAAI,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE;YAC/C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC;SACtC;QACD,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC,eAAe,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,EAAE;YACnE,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC;SACrE;IACH,CAAC;IAEO,YAAY,CAAC,iBAAiB,GAAG,KAAK;QAC5C,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO;QAChC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,KAAK,wBAAwB,CAAC,UAAU,CAAC;QAC5E,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,KAAK,wBAAwB,CAAC,QAAQ,CAAC;QACxE,MAAM,cAAc,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAEzD,IAAI,SAAS,GAAG,IAAI,CAAC;QACrB,IAAI,YAAY,EAAE;YAChB,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjE,SAAS,GAAG,cAAc,EAAE,CAAC,SAAS,CAAC,gBAAgB,cAAc,IAAI,CAAC;SAC3E;QACD,IAAI,UAAU,EAAE;YACd,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjE,SAAS,GAAG,cAAc,EAAE,CAAC,SAAS,CAAC,gBAAgB,cAAc,IAAI,CAAC;SAC3E;QAED,iBAAiB,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QAC7E,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE;YACtC,SAAS;YACT,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI;YAC/D,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI;SAChE,CAAC,CAAC;QACH,iBAAiB,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAChF,CAAC;IAEO,qBAAqB,CAAC,aAA0B;QACtD,QAAQ,IAAI,CAAC,QAAQ,EAAE;YACrB,KAAK,uBAAuB,CAAC,KAAK;gBAChC,OAAO,aAAa,CAAC,UAAU,CAAC;YAClC,KAAK,uBAAuB,CAAC,MAAM;gBACjC,OAAO,aAAa,CAAC,UAAU,GAAG,aAAa,CAAC,WAAW,GAAG,CAAC,CAAC;YAClE,KAAK,uBAAuB,CAAC,GAAG;gBAC9B,OAAO,aAAa,CAAC,UAAU,GAAG,aAAa,CAAC,WAAW,CAAC;SAC/D;IACH,CAAC;IAEO,qBAAqB,CAAC,aAA0B;QACtD,QAAQ,IAAI,CAAC,QAAQ,EAAE;YACrB,KAAK,uBAAuB,CAAC,KAAK;gBAChC,OAAO,aAAa,CAAC,SAAS,CAAC;YACjC,KAAK,uBAAuB,CAAC,MAAM;gBACjC,OAAO,aAAa,CAAC,SAAS,GAAG,aAAa,CAAC,YAAY,GAAG,CAAC,CAAC;YAClE,KAAK,uBAAuB,CAAC,GAAG;gBAC9B,OAAO,aAAa,CAAC,SAAS,GAAG,aAAa,CAAC,YAAY,CAAC;SAC/D;IACH,CAAC;IAEO,0BAA0B;QAChC,QAAQ,IAAI,CAAC,QAAQ,EAAE;YACrB,KAAK,uBAAuB,CAAC,KAAK;gBAChC,OAAO,CAAC,CAAC;YACX,KAAK,uBAAuB,CAAC,MAAM;gBACjC,OAAO,CAAC,EAAE,CAAC;YACb,KAAK,uBAAuB,CAAC,GAAG;gBAC9B,OAAO,CAAC,GAAG,CAAC;SACf;IACH,CAAC;+GAvGU,wBAAwB;mGAAxB,wBAAwB;;AAa5B;IADN,WAAW,EAAE;;0DACU;AAejB;IAFN,WAAW,EAAE;;2DAEmE;AA5BtE,wBAAwB;IALpC,YAAY,CAAC,sBAAsB,CAAC;GAKxB,wBAAwB,CAwGpC;4FAxGY,wBAAwB;kBAJpC,SAAS;mBAAC;oBACT,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,sBAAsB;iBACjC;8BAcQ,QAAQ,MAGR,aAAa;sBADnB,KAAK;uBAAC,oBAAoB;gBAIhB,MAAM;sBADhB,KAAK;uBAAC,0BAA0B;gBAU1B,SAAS;sBADf,KAAK;uBAAC,6BAA6B;gBAI7B,QAAQ;sBADd,KAAK;uBAAC,4BAA4B","sourcesContent":["import { AfterViewInit, Directive, Input, OnChanges } from '@angular/core';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { fromElementResize$ } from '@odx/angular/rxjs';\nimport { applyStyles, disableCSSTransitions, hasChanged, injectElement, isPresent, NgChanges, px, untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, distinctUntilChanged, EMPTY, 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"]}

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

@@ -0,0 +1,85 @@
+import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import { booleanAttribute, ChangeDetectorRef, Directive, EventEmitter, HostListener, inject, Input, Output, ViewChild, } from '@angular/core';
+import { detectControllerChanges } from '@odx/angular';
+import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
+import { DropdownDirective } from '@odx/angular/components/dropdown';
+import { injectElement, isFunction, untilDestroyed } from '@odx/angular/utils';
+import * as i0 from "@angular/core";
+export class AutocompleteControl extends CustomFormControl {
+    get hasOptions() {
+        return !!this.options?.length;
+    }
+    get isOpen() {
+        return !!this.dropdown?.isOpen;
+    }
+    constructor() {
+        super(null);
+        this.smoothScrollEnabled = false;
+        this.takeUntilDestroyed = untilDestroyed();
+        this.changeDetector = inject(ChangeDetectorRef);
+        this.element = injectElement();
+        this.isLoading = false;
+        this.optionSelected = new EventEmitter();
+        detectControllerChanges(this).subscribe();
+    }
+    ngAfterViewInit() {
+        if (!this.options)
+            return;
+        this.initKeyManager(this.options);
+        this.handleQueryListOption(this.options);
+        this.handleSearchFieldChanges();
+    }
+    scrollOptionIntoView({ element }) {
+        const behavior = this.smoothScrollEnabled ? 'smooth' : undefined;
+        if (isFunction(element.nativeElement.scrollIntoView)) {
+            element.nativeElement.scrollIntoView({ block: 'center', behavior });
+        }
+    }
+    initKeyManager(options) {
+        this.keyManager = new ActiveDescendantKeyManager(options).withHomeAndEnd();
+    }
+    disableSmoothScroll() {
+        this.smoothScrollEnabled = false;
+    }
+    enableSmoothScroll() {
+        this.smoothScrollEnabled = true;
+    }
+    openDropdown() {
+        this.dropdown?.open();
+    }
+    closeDropdown() {
+        this.dropdown?.close();
+    }
+    handleFocusOut(event) {
+        if (this.isOpen) {
+            event.stopImmediatePropagation();
+        }
+        this.onTouched();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AutocompleteControl, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "16.2.12", type: AutocompleteControl, isStandalone: true, inputs: { isLoading: ["isLoading", "isLoading", booleanAttribute], stringify: "stringify" }, outputs: { optionSelected: "optionSelected" }, host: { listeners: { "focusout": "handleFocusOut($event)" }, properties: { "class.is-open": "isOpen", "attr.aria-disabled": "isDisabled || null" } }, viewQueries: [{ propertyName: "dropdown", first: true, predicate: DropdownDirective, descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AutocompleteControl, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    host: {
+                        '[class.is-open]': 'isOpen',
+                        '[attr.aria-disabled]': 'isDisabled || null',
+                    },
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { dropdown: [{
+                type: ViewChild,
+                args: [DropdownDirective]
+            }], isLoading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], stringify: [{
+                type: Input
+            }], optionSelected: [{
+                type: Output
+            }], handleFocusOut: [{
+                type: HostListener,
+                args: ['focusout', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/autocomplete-control/lib/pipes/base-search-filter-pipe.mjs

@@ -0,0 +1,47 @@
+import { __decorate, __metadata } from "tslib";
+import { inject, InjectionToken } from '@angular/core';
+import { ODX_STRINGIFY, ODX_STRING_SEARCH_HANDLER } from '@odx/angular';
+import { isFunction, Pure } from '@odx/angular/utils';
+export const ODX_SEARCH_FILTER_HOST = new InjectionToken('@odx/angular/cdk/autocomplete-control::SearchFilterHost');
+export class BaseSearchFilterPipe {
+    constructor() {
+        this.stringSearchHandler = inject(ODX_STRING_SEARCH_HANDLER);
+        this.defaultStringify = inject(ODX_STRINGIFY);
+        this.hostController = inject(ODX_SEARCH_FILTER_HOST, { optional: true });
+    }
+    get searchField() {
+        return this.hostController?.searchField;
+    }
+    get stringify() {
+        return this.hostController?.stringify ?? this.defaultStringify;
+    }
+    transform(items, optionsOrHandler) {
+        const searchHandler = this.isStringSearchHandler(optionsOrHandler) ? optionsOrHandler : optionsOrHandler?.searchHandler;
+        const stringify = this.isStringSearchHandler(optionsOrHandler) ? null : optionsOrHandler?.stringify;
+        if (this.searchField) {
+            return this.filter(items, this.searchField.nativeElementValue, stringify ?? this.stringify, searchHandler ?? this.stringSearchHandler);
+        }
+        return items;
+    }
+    queryHandler(query) {
+        return query?.trim() || '';
+    }
+    filter(items, query, stringify, searchHandler) {
+        if (!items)
+            return null;
+        query = this.queryHandler(query);
+        if (query === '')
+            return items;
+        return items.filter((item) => searchHandler(stringify(item), query));
+    }
+    isStringSearchHandler(optionsOrHandler) {
+        return isFunction(optionsOrHandler);
+    }
+}
+__decorate([
+    Pure,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Function, Function]),
+    __metadata("design:returntype", Object)
+], BaseSearchFilterPipe.prototype, "filter", null);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { booleanAttribute, Directive, EventEmitter, Input, Output } from '@angular/core';
+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";
+export class CheckBoxControl extends CustomFormControl {
+    set checked(value) {
+        this.value = value;
+    }
+    get checked() {
+        return this.value;
+    }
+    get ariaChecked() {
+        return booleanToAttributeString(this.checked);
+    }
+    constructor() {
+        super(false);
+        this.element = injectElement();
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.controlValue = null;
+        this.checkedChange = new EventEmitter();
+        detectControllerChanges(this).subscribe();
+    }
+    onChanged(event) {
+        event.stopPropagation();
+        super.updateValue(event.target.checked);
+        this.checkedChange.next(this.checked);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CheckBoxControl, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "16.2.12", type: CheckBoxControl, selector: "[odxCheckBoxControl]", inputs: { checked: ["checked", "checked", booleanAttribute], controlValue: ["value", "controlValue"] }, outputs: { checkedChange: "checkedChange" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CheckBoxControl, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[odxCheckBoxControl]',
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { checked: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], controlValue: [{
+                type: Input,
+                args: ['value']
+            }], checkedChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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