@odx/angular 2.16.1 → 3.1.0

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1zZWFyY2gtZmlsdGVyLXBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2F1dG9jb21wbGV0ZS1jb250cm9sL3NyYy9saWIvcGlwZXMvYmFzZS1zZWFyY2gtZmlsdGVyLXBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUN0RSxPQUFPLEVBQUUsYUFBYSxFQUFFLHlCQUF5QixFQUFvQyxNQUFNLGNBQWMsQ0FBQztBQUUxRyxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBWXRELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLElBQUksY0FBYyxDQUFpQix5REFBeUQsQ0FBQyxDQUFDO0FBRXBJLE1BQU0sT0FBZ0Isb0JBQW9CO0lBQTFDO1FBQ21CLHdCQUFtQixHQUFHLE1BQU0sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO1FBQ3hELHFCQUFnQixHQUFHLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUN2QyxtQkFBYyxHQUFHLE1BQU0sQ0FBQyxzQkFBc0IsRUFBRSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBcUN6RixDQUFDO0lBbkNDLElBQWMsV0FBVztRQUN2QixPQUFPLElBQUksQ0FBQyxjQUFjLEVBQUUsV0FBVyxDQUFDO0lBQzFDLENBQUM7SUFFRCxJQUFjLFNBQVM7UUFDckIsT0FBTyxJQUFJLENBQUMsY0FBYyxFQUFFLFNBQVMsSUFBSSxJQUFJLENBQUMsZ0JBQWdCLENBQUM7SUFDakUsQ0FBQztJQUVNLFNBQVMsQ0FBSSxLQUFpQixFQUFFLGdCQUFtRTtRQUN4RyxNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMscUJBQXFCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLGdCQUFnQixFQUFFLGFBQWEsQ0FBQztRQUN4SCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMscUJBQXFCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsRUFBRSxTQUFTLENBQUM7UUFDcEcsSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFO1lBQ3BCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxrQkFBa0IsRUFBRSxTQUFTLElBQUssSUFBSSxDQUFDLFNBQW1CLEVBQUUsYUFBYSxJQUFJLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1NBQ25KO1FBQ0QsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRVMsWUFBWSxDQUFDLEtBQWE7UUFDbEMsT0FBTyxLQUFLLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFHTyxNQUFNLENBQUksS0FBaUIsRUFBRSxLQUFhLEVBQUUsU0FBeUIsRUFBRSxhQUFrQztRQUMvRyxJQUFJLENBQUMsS0FBSztZQUFFLE9BQU8sSUFBSSxDQUFDO1FBRXhCLEtBQUssR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRWpDLElBQUksS0FBSyxLQUFLLEVBQUU7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUUvQixPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRU8scUJBQXFCLENBQUksZ0JBQW1FO1FBQ2xHLE9BQU8sVUFBVSxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDdEMsQ0FBQztDQUNGO0FBYlM7SUFEUCxJQUFJOzs7O2tEQVNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0LCBJbmplY3Rpb25Ub2tlbiwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT0RYX1NUUklOR0lGWSwgT0RYX1NUUklOR19TRUFSQ0hfSEFORExFUiwgU3RyaW5naWZ5Rm4sIFN0cmluZ1NlYXJjaEhhbmRsZXIgfSBmcm9tICdAb2R4L2FuZ3VsYXInO1xuaW1wb3J0IHsgSW5wdXRDb250cm9sRGlyZWN0aXZlIH0gZnJvbSAnQG9keC9hbmd1bGFyL2Nkay9jdXN0b20tZm9ybS1jb250cm9sJztcbmltcG9ydCB7IGlzRnVuY3Rpb24sIFB1cmUgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuXG5pbnRlcmZhY2UgSG9zdENvbnRyb2xsZXIge1xuICBzZWFyY2hGaWVsZD86IElucHV0Q29udHJvbERpcmVjdGl2ZTtcbiAgc3RyaW5naWZ5PzogU3RyaW5naWZ5Rm48dW5rbm93bj47XG59XG5cbmludGVyZmFjZSBTZWFyY2hGaWx0ZXJQaXBlT3B0aW9uczxUPiB7XG4gIHNlYXJjaEhhbmRsZXI/OiBTdHJpbmdTZWFyY2hIYW5kbGVyO1xuICBzdHJpbmdpZnk/OiBTdHJpbmdpZnlGbjxUPjtcbn1cblxuZXhwb3J0IGNvbnN0IE9EWF9TRUFSQ0hfRklMVEVSX0hPU1QgPSBuZXcgSW5qZWN0aW9uVG9rZW48SG9zdENvbnRyb2xsZXI+KCdAb2R4L2FuZ3VsYXIvY2RrL2F1dG9jb21wbGV0ZS1jb250cm9sOjpTZWFyY2hGaWx0ZXJIb3N0Jyk7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBCYXNlU2VhcmNoRmlsdGVyUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBwcml2YXRlIHJlYWRvbmx5IHN0cmluZ1NlYXJjaEhhbmRsZXIgPSBpbmplY3QoT0RYX1NUUklOR19TRUFSQ0hfSEFORExFUik7XG4gIHByaXZhdGUgcmVhZG9ubHkgZGVmYXVsdFN0cmluZ2lmeSA9IGluamVjdChPRFhfU1RSSU5HSUZZKTtcbiAgcHJvdGVjdGVkIHJlYWRvbmx5IGhvc3RDb250cm9sbGVyID0gaW5qZWN0KE9EWF9TRUFSQ0hfRklMVEVSX0hPU1QsIHsgb3B0aW9uYWw6IHRydWUgfSk7XG5cbiAgcHJvdGVjdGVkIGdldCBzZWFyY2hGaWVsZCgpOiBJbnB1dENvbnRyb2xEaXJlY3RpdmUgfCB1bmRlZmluZWQge1xuICAgIHJldHVybiB0aGlzLmhvc3RDb250cm9sbGVyPy5zZWFyY2hGaWVsZDtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZXQgc3RyaW5naWZ5KCk6IFN0cmluZ2lmeUZuPHVua25vd24+IHtcbiAgICByZXR1cm4gdGhpcy5ob3N0Q29udHJvbGxlcj8uc3RyaW5naWZ5ID8/IHRoaXMuZGVmYXVsdFN0cmluZ2lmeTtcbiAgfVxuXG4gIHB1YmxpYyB0cmFuc2Zvcm08VD4oaXRlbXM6IFRbXSB8IG51bGwsIG9wdGlvbnNPckhhbmRsZXI/OiBTZWFyY2hGaWx0ZXJQaXBlT3B0aW9uczxUPiB8IFN0cmluZ1NlYXJjaEhhbmRsZXIpOiBUW10gfCBudWxsIHtcbiAgICBjb25zdCBzZWFyY2hIYW5kbGVyID0gdGhpcy5pc1N0cmluZ1NlYXJjaEhhbmRsZXIob3B0aW9uc09ySGFuZGxlcikgPyBvcHRpb25zT3JIYW5kbGVyIDogb3B0aW9uc09ySGFuZGxlcj8uc2VhcmNoSGFuZGxlcjtcbiAgICBjb25zdCBzdHJpbmdpZnkgPSB0aGlzLmlzU3RyaW5nU2VhcmNoSGFuZGxlcihvcHRpb25zT3JIYW5kbGVyKSA/IG51bGwgOiBvcHRpb25zT3JIYW5kbGVyPy5zdHJpbmdpZnk7XG4gICAgaWYgKHRoaXMuc2VhcmNoRmllbGQpIHtcbiAgICAgIHJldHVybiB0aGlzLmZpbHRlcihpdGVtcywgdGhpcy5zZWFyY2hGaWVsZC5uYXRpdmVFbGVtZW50VmFsdWUsIHN0cmluZ2lmeSA/PyAodGhpcy5zdHJpbmdpZnkgYXMgbmV2ZXIpLCBzZWFyY2hIYW5kbGVyID8/IHRoaXMuc3RyaW5nU2VhcmNoSGFuZGxlcik7XG4gICAgfVxuICAgIHJldHVybiBpdGVtcztcbiAgfVxuXG4gIHByb3RlY3RlZCBxdWVyeUhhbmRsZXIocXVlcnk6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHF1ZXJ5Py50cmltKCkgfHwgJyc7XG4gIH1cblxuICBAUHVyZVxuICBwcml2YXRlIGZpbHRlcjxUPihpdGVtczogVFtdIHwgbnVsbCwgcXVlcnk6IHN0cmluZywgc3RyaW5naWZ5OiBTdHJpbmdpZnlGbjxUPiwgc2VhcmNoSGFuZGxlcjogU3RyaW5nU2VhcmNoSGFuZGxlcik6IFRbXSB8IG51bGwge1xuICAgIGlmICghaXRlbXMpIHJldHVybiBudWxsO1xuXG4gICAgcXVlcnkgPSB0aGlzLnF1ZXJ5SGFuZGxlcihxdWVyeSk7XG5cbiAgICBpZiAocXVlcnkgPT09ICcnKSByZXR1cm4gaXRlbXM7XG5cbiAgICByZXR1cm4gaXRlbXMuZmlsdGVyKChpdGVtKSA9PiBzZWFyY2hIYW5kbGVyKHN0cmluZ2lmeShpdGVtKSwgcXVlcnkpKTtcbiAgfVxuXG4gIHByaXZhdGUgaXNTdHJpbmdTZWFyY2hIYW5kbGVyPFQ+KG9wdGlvbnNPckhhbmRsZXI/OiBTZWFyY2hGaWx0ZXJQaXBlT3B0aW9uczxUPiB8IFN0cmluZ1NlYXJjaEhhbmRsZXIpOiBvcHRpb25zT3JIYW5kbGVyIGlzIFN0cmluZ1NlYXJjaEhhbmRsZXIge1xuICAgIHJldHVybiBpc0Z1bmN0aW9uKG9wdGlvbnNPckhhbmRsZXIpO1xuICB9XG59XG4iXX0=

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

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

@@ -0,0 +1,120 @@
+import { __decorate } from "tslib";
+import { group, transition, trigger, useAnimation } from '@angular/animations';
+import { ChangeDetectionStrategy, Component, ElementRef, inject, Injector, Input, NgZone, Output, Renderer2, RendererStyleFlags2, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { autoUpdate } from '@floating-ui/dom';
+import { CoreModule } from '@odx/angular';
+import { fadeIn, fadeOut, slideInLeft, slideInRight, slideInUp, slideOutDown, slideOutLeft, slideOutRight, slideOutUp, waitForChildAnimations, } from '@odx/angular/animations';
+import { DynamicViewDirective } from '@odx/angular/cdk/dynamic-view';
+import { CSSComponent } from '@odx/angular/internal';
+import { getSide, hasChanged, injectElement, isPresent } from '@odx/angular/utils';
+import { Subject } from 'rxjs';
+import { computeOverlayPosition } from './helpers';
+import { DefaultConnectedOverlayOptions } from './models';
+import * as i0 from "@angular/core";
+export let ConnectedOverlayComponent = class ConnectedOverlayComponent {
+    constructor() {
+        this.renderer = inject(Renderer2);
+        this.zone = inject(NgZone);
+        this.positionUpdater = null;
+        this.injector = inject(Injector);
+        this.element = injectElement();
+        this.options = DefaultConnectedOverlayOptions;
+        this.closed = new Subject();
+    }
+    ngOnChanges(changes) {
+        if (hasChanged(changes, ['options'], false)) {
+            this.overlaySide = getSide(this.options.position);
+        }
+        if (hasChanged(changes, ['referenceElement', 'options'], false)) {
+            this.stopPositionUpdater();
+            this.startPositionUpdater();
+        }
+    }
+    ngOnDestroy() {
+        this.stopPositionUpdater();
+    }
+    onAnimationStart({ fromState, toState }) {
+        if (!fromState)
+            return;
+        if (fromState === 'void') {
+            this.renderer.setStyle(this.element.nativeElement, 'pointer-events', 'none', RendererStyleFlags2.Important);
+            this.options.hooks?.beforeOpen?.();
+        }
+        else if (toState === 'void') {
+            this.options.hooks?.beforeClose?.();
+        }
+    }
+    onAnimationDone({ fromState, toState }) {
+        if (!fromState)
+            return;
+        if (fromState === 'void') {
+            this.options.hooks?.afterOpen?.();
+            this.renderer.removeStyle(this.element.nativeElement, 'pointer-events');
+        }
+        else if (toState === 'void') {
+            this.options.hooks?.afterClose?.();
+        }
+    }
+    startPositionUpdater() {
+        this.positionUpdater = this.zone.runOutsideAngular(() => autoUpdate(this.referenceElement, this.element.nativeElement, () => this.updatePosition(), {
+            elementResize: isPresent(window.ResizeObserver),
+        }));
+    }
+    stopPositionUpdater() {
+        this.positionUpdater?.();
+        this.positionUpdater = null;
+    }
+    async updatePosition() {
+        return computeOverlayPosition(this.referenceElement, this.element.nativeElement, this.contentElement.nativeElement, this.arrowElement.nativeElement, this.options).then(({ placement }) => {
+            this.overlaySide = getSide(placement);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectedOverlayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ConnectedOverlayComponent, isStandalone: true, selector: "odx-connected-overlay", inputs: { referenceElement: "referenceElement", options: "options" }, outputs: { closed: "closed" }, host: { properties: { "@hostAnimation": "true" } }, viewQueries: [{ propertyName: "contentElement", first: true, predicate: ["content"], descendants: true, static: true }, { propertyName: "arrowElement", first: true, predicate: ["arrow"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div\n  [@contentAnimation]=\"overlaySide\"\n  (@contentAnimation.start)=\"onAnimationStart($event)\"\n  (@contentAnimation.done)=\"onAnimationDone($event)\"\n  class=\"odx-cdk-connected-overlay__content {{ options.containerClass }}\"\n  #content\n>\n  <ng-template [odxDynamicView]=\"options.content\" [odxDynamicViewContext]=\"options.context\" [odxDynamicViewInjector]=\"injector\"></ng-template>\n  <div class=\"odx-cdk-connected-overlay-arrow\" #arrow></div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "directive", type: DynamicViewDirective, selector: "ng-template[odxDynamicView]", inputs: ["odxDynamicView", "odxDynamicViewInjector", "odxDynamicViewContext"] }], animations: [
+            trigger('hostAnimation', [waitForChildAnimations]),
+            trigger('contentAnimation', [
+                transition('void => top', group([useAnimation(slideInUp, { params: { from: '-8px' } }), useAnimation(fadeIn())])),
+                transition('top => void', group([useAnimation(slideOutUp, { params: { to: '-8px' } }), useAnimation(fadeOut())])),
+                transition('void => right', group([useAnimation(slideInLeft, { params: { from: '8px' } }), useAnimation(fadeIn())])),
+                transition('right => void', group([useAnimation(slideOutRight, { params: { to: '8px' } }), useAnimation(fadeOut())])),
+                transition('void => bottom', group([useAnimation(slideInUp, { params: { from: '8px' } }), useAnimation(fadeIn())])),
+                transition('bottom => void', group([useAnimation(slideOutDown, { params: { to: '8px' } }), useAnimation(fadeOut())])),
+                transition('void => left', group([useAnimation(slideInRight, { params: { from: '-8px' } }), useAnimation(fadeIn())])),
+                transition('left => void', group([useAnimation(slideOutLeft, { params: { to: '-8px' } }), useAnimation(fadeOut())])),
+            ]),
+        ], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+};
+ConnectedOverlayComponent = __decorate([
+    CSSComponent('cdk-connected-overlay')
+], ConnectedOverlayComponent);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectedOverlayComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'odx-connected-overlay', imports: [CoreModule, DynamicViewDirective], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        '[@hostAnimation]': 'true',
+                    }, animations: [
+                        trigger('hostAnimation', [waitForChildAnimations]),
+                        trigger('contentAnimation', [
+                            transition('void => top', group([useAnimation(slideInUp, { params: { from: '-8px' } }), useAnimation(fadeIn())])),
+                            transition('top => void', group([useAnimation(slideOutUp, { params: { to: '-8px' } }), useAnimation(fadeOut())])),
+                            transition('void => right', group([useAnimation(slideInLeft, { params: { from: '8px' } }), useAnimation(fadeIn())])),
+                            transition('right => void', group([useAnimation(slideOutRight, { params: { to: '8px' } }), useAnimation(fadeOut())])),
+                            transition('void => bottom', group([useAnimation(slideInUp, { params: { from: '8px' } }), useAnimation(fadeIn())])),
+                            transition('bottom => void', group([useAnimation(slideOutDown, { params: { to: '8px' } }), useAnimation(fadeOut())])),
+                            transition('void => left', group([useAnimation(slideInRight, { params: { from: '-8px' } }), useAnimation(fadeIn())])),
+                            transition('left => void', group([useAnimation(slideOutLeft, { params: { to: '-8px' } }), useAnimation(fadeOut())])),
+                        ]),
+                    ], template: "<div\n  [@contentAnimation]=\"overlaySide\"\n  (@contentAnimation.start)=\"onAnimationStart($event)\"\n  (@contentAnimation.done)=\"onAnimationDone($event)\"\n  class=\"odx-cdk-connected-overlay__content {{ options.containerClass }}\"\n  #content\n>\n  <ng-template [odxDynamicView]=\"options.content\" [odxDynamicViewContext]=\"options.context\" [odxDynamicViewInjector]=\"injector\"></ng-template>\n  <div class=\"odx-cdk-connected-overlay-arrow\" #arrow></div>\n</div>\n" }]
+        }], propDecorators: { contentElement: [{
+                type: ViewChild,
+                args: ['content', { static: true }]
+            }], arrowElement: [{
+                type: ViewChild,
+                args: ['arrow', { static: true }]
+            }], referenceElement: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], closed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connected-overlay.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/connected-overlay/src/lib/connected-overlay.component.ts","../../../../../../../libs/angular/cdk/connected-overlay/src/lib/connected-overlay.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AnimationEvent, group, transition, trigger, useAnimation } from '@angular/animations';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  inject,\n  Injector,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  Renderer2,\n  RendererStyleFlags2,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { autoUpdate, VirtualElement } from '@floating-ui/dom';\nimport { CoreModule } from '@odx/angular';\nimport {\n  fadeIn,\n  fadeOut,\n  slideInLeft,\n  slideInRight,\n  slideInUp,\n  slideOutDown,\n  slideOutLeft,\n  slideOutRight,\n  slideOutUp,\n  waitForChildAnimations,\n} from '@odx/angular/animations';\nimport { DynamicViewDirective } from '@odx/angular/cdk/dynamic-view';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { getSide, hasChanged, injectElement, isPresent, NgChanges, Side } from '@odx/angular/utils';\nimport { Subject } from 'rxjs';\nimport { computeOverlayPosition } from './helpers';\nimport { ConnectedOverlayOptions, DefaultConnectedOverlayOptions } from './models';\n\n@CSSComponent('cdk-connected-overlay')\n@Component({\n  standalone: true,\n  selector: 'odx-connected-overlay',\n  imports: [CoreModule, DynamicViewDirective],\n  templateUrl: 'connected-overlay.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    '[@hostAnimation]': 'true',\n  },\n  animations: [\n    trigger('hostAnimation', [waitForChildAnimations]),\n    trigger('contentAnimation', [\n      transition('void => top', group([useAnimation(slideInUp, { params: { from: '-8px' } }), useAnimation(fadeIn())])),\n      transition('top => void', group([useAnimation(slideOutUp, { params: { to: '-8px' } }), useAnimation(fadeOut())])),\n      transition('void => right', group([useAnimation(slideInLeft, { params: { from: '8px' } }), useAnimation(fadeIn())])),\n      transition('right => void', group([useAnimation(slideOutRight, { params: { to: '8px' } }), useAnimation(fadeOut())])),\n      transition('void => bottom', group([useAnimation(slideInUp, { params: { from: '8px' } }), useAnimation(fadeIn())])),\n      transition('bottom => void', group([useAnimation(slideOutDown, { params: { to: '8px' } }), useAnimation(fadeOut())])),\n      transition('void => left', group([useAnimation(slideInRight, { params: { from: '-8px' } }), useAnimation(fadeIn())])),\n      transition('left => void', group([useAnimation(slideOutLeft, { params: { to: '-8px' } }), useAnimation(fadeOut())])),\n    ]),\n  ],\n})\nexport class ConnectedOverlayComponent implements OnChanges, OnDestroy {\n  private readonly renderer = inject(Renderer2);\n  private readonly zone = inject(NgZone);\n  private positionUpdater: (() => void) | null = null;\n\n  protected readonly injector = inject(Injector);\n  protected overlaySide?: Side;\n\n  @ViewChild('content', { static: true })\n  protected contentElement!: ElementRef<HTMLElement>;\n\n  @ViewChild('arrow', { static: true })\n  protected arrowElement!: ElementRef<HTMLElement>;\n\n  public readonly element = injectElement();\n\n  @Input()\n  public referenceElement!: VirtualElement;\n\n  @Input()\n  public options: ConnectedOverlayOptions = DefaultConnectedOverlayOptions;\n\n  @Output()\n  public closed = new Subject<void>();\n\n  public ngOnChanges(changes: NgChanges<ConnectedOverlayComponent>): void {\n    if (hasChanged(changes, ['options'], false)) {\n      this.overlaySide = getSide(this.options.position);\n    }\n    if (hasChanged(changes, ['referenceElement', 'options'], false)) {\n      this.stopPositionUpdater();\n      this.startPositionUpdater();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.stopPositionUpdater();\n  }\n\n  protected onAnimationStart({ fromState, toState }: AnimationEvent): void {\n    if (!fromState) return;\n    if (fromState === 'void') {\n      this.renderer.setStyle(this.element.nativeElement, 'pointer-events', 'none', RendererStyleFlags2.Important);\n      this.options.hooks?.beforeOpen?.();\n    } else if (toState === 'void') {\n      this.options.hooks?.beforeClose?.();\n    }\n  }\n\n  protected onAnimationDone({ fromState, toState }: AnimationEvent): void {\n    if (!fromState) return;\n    if (fromState === 'void') {\n      this.options.hooks?.afterOpen?.();\n      this.renderer.removeStyle(this.element.nativeElement, 'pointer-events');\n    } else if (toState === 'void') {\n      this.options.hooks?.afterClose?.();\n    }\n  }\n\n  private startPositionUpdater(): void {\n    this.positionUpdater = this.zone.runOutsideAngular(() =>\n      autoUpdate(this.referenceElement, this.element.nativeElement, () => this.updatePosition(), {\n        elementResize: isPresent(window.ResizeObserver),\n      }),\n    );\n  }\n\n  private stopPositionUpdater(): void {\n    this.positionUpdater?.();\n    this.positionUpdater = null;\n  }\n\n  private async updatePosition(): Promise<void> {\n    return computeOverlayPosition(\n      this.referenceElement,\n      this.element.nativeElement,\n      this.contentElement.nativeElement,\n      this.arrowElement.nativeElement,\n      this.options,\n    ).then(({ placement }) => {\n      this.overlaySide = getSide(placement);\n    });\n  }\n}\n","<div\n  [@contentAnimation]=\"overlaySide\"\n  (@contentAnimation.start)=\"onAnimationStart($event)\"\n  (@contentAnimation.done)=\"onAnimationDone($event)\"\n  class=\"odx-cdk-connected-overlay__content {{ options.containerClass }}\"\n  #content\n>\n  <ng-template [odxDynamicView]=\"options.content\" [odxDynamicViewContext]=\"options.context\" [odxDynamicViewInjector]=\"injector\"></ng-template>\n  <div class=\"odx-cdk-connected-overlay-arrow\" #arrow></div>\n</div>\n"]}

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

@@ -0,0 +1,25 @@
+import { inject, Injectable } from '@angular/core';
+import { DynamicViewService } from '@odx/angular/cdk/dynamic-view';
+import { deepmerge } from '@odx/angular/internal';
+import { ConnectedOverlayComponent } from './connected-overlay.component';
+import { ConnectedOverlayRef, DefaultConnectedOverlayOptions } from './models';
+import * as i0 from "@angular/core";
+export class ConnectedOverlayService {
+    constructor() {
+        this.dynamicViewService = inject(DynamicViewService);
+    }
+    createOverlay(referenceElement, options, renderingOptions) {
+        const dynamicViewRef = this.dynamicViewService.createView(ConnectedOverlayComponent, {
+            ...renderingOptions,
+            context: { options: deepmerge(DefaultConnectedOverlayOptions, options), referenceElement },
+        });
+        return new ConnectedOverlayRef(dynamicViewRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectedOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectedOverlayService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectedOverlayService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/custom-form-control/lib/control.directive.mjs

@@ -0,0 +1,19 @@
+import { Directive } from '@angular/core';
+import { injectElement } from '@odx/angular/utils';
+import * as i0 from "@angular/core";
+export class ControlDirective {
+    constructor() {
+        this.element = injectElement();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ControlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ControlDirective, isStandalone: true, selector: "[odxControl]", exportAs: ["odxControl"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[odxControl]',
+                    exportAs: 'odxControl',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2N1c3RvbS1mb3JtLWNvbnRyb2wvc3JjL2xpYi9jb250cm9sLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFPbkQsTUFBTSxPQUFPLGdCQUFnQjtJQUw3QjtRQU1rQixZQUFPLEdBQUcsYUFBYSxFQUFFLENBQUM7S0FDM0M7K0dBRlksZ0JBQWdCO21HQUFoQixnQkFBZ0I7OzRGQUFoQixnQkFBZ0I7a0JBTDVCLFNBQVM7bUJBQUM7b0JBQ1QsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLFFBQVEsRUFBRSxjQUFjO29CQUN4QixRQUFRLEVBQUUsWUFBWTtpQkFDdkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGluamVjdEVsZW1lbnQgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgc2VsZWN0b3I6ICdbb2R4Q29udHJvbF0nLFxuICBleHBvcnRBczogJ29keENvbnRyb2wnLFxufSlcbmV4cG9ydCBjbGFzcyBDb250cm9sRGlyZWN0aXZlIHtcbiAgcHVibGljIHJlYWRvbmx5IGVsZW1lbnQgPSBpbmplY3RFbGVtZW50KCk7XG59XG4iXX0=

package/esm2022/cdk/custom-form-control/lib/custom-form-control.mjs

@@ -0,0 +1,114 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, inject, Input, ViewChild } from '@angular/core';
+import { NgControl, RequiredValidator, Validators } from '@angular/forms';
+import { Controller, DisabledController, ReadonlyController } from '@odx/angular';
+import { arrayAttribute, Pure } from '@odx/angular/utils';
+import { ControlDirective } from './control.directive';
+import * as i0 from "@angular/core";
+export class CustomFormControl extends Controller {
+    static { this.CURRENT_INDEX = 0; }
+    set value(value) {
+        if (this.internalValue !== value) {
+            this.internalValue = value;
+            this.triggerControllerChange();
+        }
+    }
+    get value() {
+        return this.internalValue;
+    }
+    get hasError() {
+        return !!this.ngControl?.touched && !!this.ngControl?.invalid && this.hasNonIgnoredError(this.ngControl.errors);
+    }
+    get isDisabled() {
+        return !!this.disabledController?.disabled;
+    }
+    get isReadonly() {
+        return !!this.readonlyController?.readonly;
+    }
+    get isRequired() {
+        return !!this.requiredValidator?.required || this.hasValidator(Validators.required) || this.hasValidator(Validators.requiredTrue);
+    }
+    constructor(initialValue) {
+        super();
+        this.requiredValidator = inject(RequiredValidator, { optional: true, self: true });
+        this.disabledController = DisabledController.inject();
+        this.readonlyController = ReadonlyController.inject();
+        this.ngControl = inject(NgControl, { self: true, optional: true });
+        this.id = null;
+        this.name = `odx-form-control-${CustomFormControl.CURRENT_INDEX++}`;
+        this.tabindex = null;
+        this.ignoreErrors = [];
+        this.control = null;
+        this.internalValue = initialValue;
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    onTouched() {
+        // implemented by control value accessor
+    }
+    onChange(_value) {
+        // implemented by control value accessor
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabledController?.setDisabledState(isDisabled);
+    }
+    writeValue(value) {
+        if (this.isDisabled)
+            return;
+        this.value = value;
+        this.onChange(value);
+    }
+    updateValue(value) {
+        if (this.isDisabled)
+            return;
+        this.writeValue(value);
+        this.onTouched();
+    }
+    hasValidator(validator) {
+        return !!this.ngControl?.control?.hasValidator(validator);
+    }
+    hasNonIgnoredError(errors) {
+        if (!errors)
+            return false;
+        return Object.keys(errors).some((error) => !this.ignoreErrors.includes(error));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CustomFormControl, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "16.2.12", type: CustomFormControl, inputs: { id: "id", name: "name", tabindex: "tabindex", ignoreErrors: ["ignoreErrors", "ignoreErrors", arrayAttribute] }, host: { properties: { "class.has-error": "hasError", "class.is-disabled": "isDisabled", "class.is-readonly": "isReadonly", "class.is-required": "required" } }, viewQueries: [{ propertyName: "control", first: true, predicate: ControlDirective, descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+__decorate([
+    Pure,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Boolean)
+], CustomFormControl.prototype, "hasNonIgnoredError", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CustomFormControl, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[class.has-error]': 'hasError',
+                        '[class.is-disabled]': 'isDisabled',
+                        '[class.is-readonly]': 'isReadonly',
+                        '[class.is-required]': 'required',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: undefined }]; }, propDecorators: { id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], tabindex: [{
+                type: Input
+            }], ignoreErrors: [{
+                type: Input,
+                args: [{ transform: arrayAttribute }]
+            }], control: [{
+                type: ViewChild,
+                args: [ControlDirective]
+            }], hasNonIgnoredError: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-form-control.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/custom-form-control/src/lib/custom-form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, Input, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NgControl, RequiredValidator, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\nimport { Controller, DisabledController, ReadonlyController } from '@odx/angular';\nimport { arrayAttribute, Pure } from '@odx/angular/utils';\nimport { ControlDirective } from './control.directive';\n\n@Directive({\n  host: {\n    '[class.has-error]': 'hasError',\n    '[class.is-disabled]': 'isDisabled',\n    '[class.is-readonly]': 'isReadonly',\n    '[class.is-required]': 'required',\n  },\n})\nexport abstract class CustomFormControl<T> extends Controller implements ControlValueAccessor {\n  private static CURRENT_INDEX = 0;\n\n  private readonly requiredValidator = inject(RequiredValidator, { optional: true, self: true });\n  private internalValue: T;\n  protected readonly disabledController = DisabledController.inject();\n  protected readonly readonlyController = ReadonlyController.inject();\n  protected readonly ngControl = inject(NgControl, { self: true, optional: true });\n\n  @Input()\n  public id: string | null = null;\n\n  @Input()\n  public name = `odx-form-control-${CustomFormControl.CURRENT_INDEX++}`;\n\n  @Input()\n  public tabindex: string | null = null;\n\n  @Input({ transform: arrayAttribute })\n  public ignoreErrors: string[] = [];\n\n  public set value(value: T) {\n    if (this.internalValue !== value) {\n      this.internalValue = value;\n      this.triggerControllerChange();\n    }\n  }\n  public get value(): T {\n    return this.internalValue;\n  }\n\n  public get hasError(): boolean {\n    return !!this.ngControl?.touched && !!this.ngControl?.invalid && this.hasNonIgnoredError(this.ngControl.errors);\n  }\n\n  public get isDisabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  public get isReadonly(): boolean {\n    return !!this.readonlyController?.readonly;\n  }\n\n  public get isRequired(): boolean {\n    return !!this.requiredValidator?.required || this.hasValidator(Validators.required) || this.hasValidator(Validators.requiredTrue);\n  }\n\n  @ViewChild(ControlDirective)\n  public readonly control: ControlDirective | null = null;\n\n  constructor(initialValue: T) {\n    super();\n    this.internalValue = initialValue;\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  public onTouched() {\n    // implemented by control value accessor\n  }\n\n  public onChange(_value: T) {\n    // implemented by control value accessor\n  }\n\n  public registerOnChange(fn: (value: T) => void): void {\n    this.onChange = fn;\n  }\n\n  public registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabledController?.setDisabledState(isDisabled);\n  }\n\n  public writeValue(value: T): void {\n    if (this.isDisabled) return;\n    this.value = value;\n    this.onChange(value);\n  }\n\n  public updateValue(value: T): void {\n    if (this.isDisabled) return;\n    this.writeValue(value);\n    this.onTouched();\n  }\n\n  protected hasValidator(validator: ValidatorFn): boolean {\n    return !!this.ngControl?.control?.hasValidator(validator);\n  }\n\n  @Pure\n  private hasNonIgnoredError(errors: ValidationErrors | null): boolean {\n    if (!errors) return false;\n\n    return Object.keys(errors).some((error) => !this.ignoreErrors.includes(error));\n  }\n}\n"]}

package/esm2022/cdk/custom-form-control/lib/input-control.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive } from '@angular/core';
+import { injectElement, untilDestroyed } from '@odx/angular/utils';
+import { distinctUntilChanged, fromEvent, map } from 'rxjs';
+import * as i0 from "@angular/core";
+export class InputControlDirective {
+    constructor() {
+        this.takeUntilDestroyed = untilDestroyed();
+        this.element = injectElement();
+        this.valueChange$ = fromEvent(this.element.nativeElement, 'input').pipe(distinctUntilChanged(), map(() => this.nativeElementValue));
+    }
+    get nativeElementValue() {
+        return this.element.nativeElement.value;
+    }
+    set nativeElementValue(value) {
+        this.element.nativeElement.value = value;
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    blur() {
+        this.element.nativeElement.blur();
+    }
+    reset() {
+        this.element.nativeElement.value = '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InputControlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: InputControlDirective, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InputControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/dynamic-view/lib/dynamic-view.component.mjs

@@ -0,0 +1,43 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { injectElement } from '@odx/angular/utils';
+import { distinctUntilChanged, isObservable } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DynamicViewComponent {
+    constructor() {
+        this.element = injectElement();
+        this.currentSubscription = null;
+    }
+    set content(value) {
+        if (isObservable(value)) {
+            this.ngOnDestroy();
+            this.currentSubscription = value.pipe(distinctUntilChanged()).subscribe((innerValue) => {
+                this.setContent(innerValue);
+            });
+        }
+        else {
+            this.setContent(value);
+        }
+    }
+    ngOnDestroy() {
+        this.currentSubscription?.unsubscribe();
+        this.currentSubscription = null;
+    }
+    setContent(value) {
+        this.element.nativeElement.innerHTML = value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: DynamicViewComponent, isStandalone: true, selector: "odx-dynamic-view", inputs: { content: "content" }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'odx-dynamic-view',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    standalone: true,
+                }]
+        }], propDecorators: { content: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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