@odx/angular 1.0.0-rc.6 → 1.0.0-rc.7

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

@@ -0,0 +1,112 @@
+import { __decorate } from "tslib";
+import { group, transition, trigger, useAnimation } from '@angular/animations';
+import { ChangeDetectionStrategy, Component, ElementRef, inject, 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 { getInjector, hasChanged, injectElement } from '@odx/angular/utils';
+import { Subject } from 'rxjs';
+import { computeOverlayPosition, getOverlaySide } from './helpers';
+import { DefaultConnectedOverlayOptions } from './models';
+import * as i0 from "@angular/core";
+let ConnectedOverlayComponent = class ConnectedOverlayComponent {
+    constructor() {
+        this.renderer = inject(Renderer2);
+        this.zone = inject(NgZone);
+        this.positionUpdater = null;
+        this.injector = getInjector();
+        this.element = injectElement();
+        this.options = DefaultConnectedOverlayOptions;
+        this.closed = new Subject();
+    }
+    ngOnChanges(changes) {
+        if (hasChanged(changes, ['options'], false)) {
+            this.overlaySide = getOverlaySide(this.options.position);
+        }
+        if (hasChanged(changes, ['referenceElement', 'options'], false)) {
+            this.stopPositionUpdater();
+            this.startPositionUpdater();
+        }
+    }
+    ngOnDestroy() {
+        this.stopPositionUpdater();
+    }
+    onAnimationStart({ fromState }) {
+        if (fromState === 'void') {
+            this.renderer.setStyle(this.element.nativeElement, 'pointer-events', 'none', RendererStyleFlags2.Important);
+            this.options.hooks?.beforeOpen?.();
+        }
+        else {
+            this.options.hooks?.beforeClose?.();
+        }
+    }
+    onAnimationDone({ fromState }) {
+        if (fromState === 'void') {
+            this.options.hooks?.afterOpen?.();
+            this.renderer.removeStyle(this.element.nativeElement, 'pointer-events');
+        }
+        else {
+            this.options.hooks?.afterClose?.();
+        }
+    }
+    startPositionUpdater() {
+        this.positionUpdater = this.zone.runOutsideAngular(() => autoUpdate(this.referenceElement, this.element.nativeElement, () => computeOverlayPosition(this.referenceElement, this.element.nativeElement, this.contentElement.nativeElement, this.arrowElement.nativeElement, this.options).then(({ placement }) => {
+            this.overlaySide = getOverlaySide(placement);
+        })));
+    }
+    stopPositionUpdater() {
+        this.positionUpdater?.();
+        this.positionUpdater = null;
+    }
+};
+ConnectedOverlayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ConnectedOverlayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ConnectedOverlayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.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);
+export { ConnectedOverlayComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.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  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  Renderer2,\n  RendererStyleFlags2,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { autoUpdate, Side, 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 { getInjector, hasChanged, injectElement, NgChanges } from '@odx/angular/utils';\nimport { Subject } from 'rxjs';\nimport { computeOverlayPosition, getOverlaySide } 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 = getInjector();\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 = getOverlaySide(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 }: AnimationEvent): void {\n    if (fromState === 'void') {\n      this.renderer.setStyle(this.element.nativeElement, 'pointer-events', 'none', RendererStyleFlags2.Important);\n      this.options.hooks?.beforeOpen?.();\n    } else {\n      this.options.hooks?.beforeClose?.();\n    }\n  }\n\n  protected onAnimationDone({ fromState }: AnimationEvent): void {\n    if (fromState === 'void') {\n      this.options.hooks?.afterOpen?.();\n      this.renderer.removeStyle(this.element.nativeElement, 'pointer-events');\n    } else {\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, () =>\n        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 = getOverlaySide(placement);\n        })\n      )\n    );\n  }\n\n  private stopPositionUpdater(): void {\n    this.positionUpdater?.();\n    this.positionUpdater = null;\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/esm2020/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 'deepmerge-ts';
+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);
+    }
+}
+ConnectedOverlayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ConnectedOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ConnectedOverlayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ConnectedOverlayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ConnectedOverlayService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cdk/connected-overlay/lib/helpers/compute-overlay-position.mjs

@@ -0,0 +1,57 @@
+import { arrow, computePosition, flip, hide, offset as withOffset, shift, size } from '@floating-ui/dom';
+import { applyStyles, cssTranslate, px } from '@odx/angular/utils';
+import { getOppositeOverlaySide } from './get-opposite-overlay-side';
+import { getOverlaySide } from './get-overlay-side';
+export async function computeOverlayPosition(referenceElement, overlayElement, contentElement, arrowElement, options) {
+    const { position, offset, outerPadding, matchReferenceWidth, enableFallback, strategy, minHeight } = options;
+    const arrowSize = options.showArrow ? arrowElement.offsetWidth : 0;
+    const arrowMiddleware = options.showArrow ? [arrow({ element: arrowElement, padding: 8 })] : [];
+    const flipMiddleWare = enableFallback ? [flip()] : [];
+    return computePosition(referenceElement, overlayElement, {
+        strategy,
+        placement: position,
+        middleware: [
+            withOffset(Math.max(offset, arrowSize + offset)),
+            shift({ padding: outerPadding }),
+            ...flipMiddleWare,
+            size({
+                padding: outerPadding,
+                apply: ({ availableHeight, availableWidth, rects }) => {
+                    applyStyles(contentElement, {
+                        maxHeight: px(availableHeight),
+                        maxWidth: px(availableWidth),
+                        minHeight: minHeight ? px(Math.min(availableHeight, minHeight)) : null,
+                        minWidth: matchReferenceWidth ? px(rects.reference.width) : null,
+                    });
+                },
+            }),
+            ...arrowMiddleware,
+            hide(),
+        ],
+    }).then((result) => {
+        applyStyles(overlayElement, {
+            top: '0',
+            left: '0',
+            transform: cssTranslate(px(result.x), px(result.y)),
+        });
+        if (options.hiddenClass) {
+            overlayElement.classList.toggle(options.hiddenClass, !!result.middlewareData.hide?.referenceHidden);
+        }
+        if (options.showArrow) {
+            const overlaySide = getOverlaySide(result.placement);
+            const arrowSide = getOppositeOverlaySide(overlaySide);
+            applyStyles(arrowElement, {
+                display: null,
+                top: px(result.middlewareData.arrow?.y),
+                left: px(result.middlewareData.arrow?.x),
+                [arrowSide]: px(-arrowSize / 2),
+                [overlaySide]: null,
+            });
+        }
+        else {
+            applyStyles(arrowElement, { display: 'none' });
+        }
+        return result;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cdk/connected-overlay/lib/helpers/get-opposite-overlay-side.mjs

@@ -0,0 +1,13 @@
+export function getOppositeOverlaySide(overlaySide) {
+    switch (overlaySide) {
+        case 'top':
+            return 'bottom';
+        case 'right':
+            return 'left';
+        case 'bottom':
+            return 'top';
+        case 'left':
+            return 'right';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW9wcG9zaXRlLW92ZXJsYXktc2lkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jZGsvY29ubmVjdGVkLW92ZXJsYXkvc3JjL2xpYi9oZWxwZXJzL2dldC1vcHBvc2l0ZS1vdmVybGF5LXNpZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLHNCQUFzQixDQUFDLFdBQWlCO0lBQ3RELFFBQVEsV0FBVyxFQUFFO1FBQ25CLEtBQUssS0FBSztZQUNSLE9BQU8sUUFBUSxDQUFDO1FBQ2xCLEtBQUssT0FBTztZQUNWLE9BQU8sTUFBTSxDQUFDO1FBQ2hCLEtBQUssUUFBUTtZQUNYLE9BQU8sS0FBSyxDQUFDO1FBQ2YsS0FBSyxNQUFNO1lBQ1QsT0FBTyxPQUFPLENBQUM7S0FDbEI7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2lkZSB9IGZyb20gJ0BmbG9hdGluZy11aS9kb20nO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0T3Bwb3NpdGVPdmVybGF5U2lkZShvdmVybGF5U2lkZTogU2lkZSk6IFNpZGUge1xuICBzd2l0Y2ggKG92ZXJsYXlTaWRlKSB7XG4gICAgY2FzZSAndG9wJzpcbiAgICAgIHJldHVybiAnYm90dG9tJztcbiAgICBjYXNlICdyaWdodCc6XG4gICAgICByZXR1cm4gJ2xlZnQnO1xuICAgIGNhc2UgJ2JvdHRvbSc6XG4gICAgICByZXR1cm4gJ3RvcCc7XG4gICAgY2FzZSAnbGVmdCc6XG4gICAgICByZXR1cm4gJ3JpZ2h0JztcbiAgfVxufVxuIl19

package/esm2020/cdk/connected-overlay/lib/helpers/get-overlay-side.mjs

@@ -0,0 +1,4 @@
+export function getOverlaySide(position) {
+    return position.split('-')[0];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW92ZXJsYXktc2lkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jZGsvY29ubmVjdGVkLW92ZXJsYXkvc3JjL2xpYi9oZWxwZXJzL2dldC1vdmVybGF5LXNpZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGNBQWMsQ0FBQyxRQUFtQjtJQUNoRCxPQUFPLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFTLENBQUM7QUFDeEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBsYWNlbWVudCwgU2lkZSB9IGZyb20gJ0BmbG9hdGluZy11aS9kb20nO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0T3ZlcmxheVNpZGUocG9zaXRpb246IFBsYWNlbWVudCk6IFNpZGUge1xuICByZXR1cm4gcG9zaXRpb24uc3BsaXQoJy0nKVswXSBhcyBTaWRlO1xufVxuIl19

package/esm2020/cdk/connected-overlay/lib/helpers/index.mjs

@@ -0,0 +1,4 @@
+export * from './compute-overlay-position';
+export * from './get-opposite-overlay-side';
+export * from './get-overlay-side';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2Nvbm5lY3RlZC1vdmVybGF5L3NyYy9saWIvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcHV0ZS1vdmVybGF5LXBvc2l0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZ2V0LW9wcG9zaXRlLW92ZXJsYXktc2lkZSc7XG5leHBvcnQgKiBmcm9tICcuL2dldC1vdmVybGF5LXNpZGUnO1xuIl19

package/esm2020/cdk/connected-overlay/lib/models/connected-overlay-options.mjs

@@ -0,0 +1,10 @@
+export const DefaultConnectedOverlayOptions = {
+    hiddenClass: 'is-hidden',
+    enableFallback: false,
+    matchReferenceWidth: false,
+    offset: 4,
+    outerPadding: 12,
+    position: 'bottom',
+    strategy: 'fixed',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGVkLW92ZXJsYXktb3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jZGsvY29ubmVjdGVkLW92ZXJsYXkvc3JjL2xpYi9tb2RlbHMvY29ubmVjdGVkLW92ZXJsYXktb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF3QkEsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQTRCO0lBQ3JFLFdBQVcsRUFBRSxXQUFXO0lBQ3hCLGNBQWMsRUFBRSxLQUFLO0lBQ3JCLG1CQUFtQixFQUFFLEtBQUs7SUFDMUIsTUFBTSxFQUFFLENBQUM7SUFDVCxZQUFZLEVBQUUsRUFBRTtJQUNoQixRQUFRLEVBQUUsUUFBUTtJQUNsQixRQUFRLEVBQUUsT0FBTztDQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGxhY2VtZW50LCBTdHJhdGVneSB9IGZyb20gJ0BmbG9hdGluZy11aS9kb20nO1xuaW1wb3J0IHsgRHluYW1pY0NvbnRlbnQgfSBmcm9tICdAb2R4L2FuZ3VsYXIvY2RrL2R5bmFtaWMtdmlldyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29ubmVjdGVkT3ZlcmxheU9wdGlvbnMge1xuICBjb250ZW50PzogRHluYW1pY0NvbnRlbnQgfCBudWxsO1xuICBjb250ZXh0PzogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG4gIGNvbnRhaW5lckNsYXNzPzogc3RyaW5nIHwgbnVsbDtcbiAgaGlkZGVuQ2xhc3M6IHN0cmluZyB8IG51bGw7XG4gIGVuYWJsZUZhbGxiYWNrOiBib29sZWFuO1xuICBtYXRjaFJlZmVyZW5jZVdpZHRoOiBib29sZWFuO1xuICBtaW5IZWlnaHQ/OiBudW1iZXIgfCBudWxsO1xuICBvZmZzZXQ6IG51bWJlcjtcbiAgb3V0ZXJQYWRkaW5nOiBudW1iZXI7XG4gIHBvc2l0aW9uOiBQbGFjZW1lbnQ7XG4gIHN0cmF0ZWd5OiBTdHJhdGVneTtcbiAgc2hvd0Fycm93PzogYm9vbGVhbjtcbiAgaG9va3M/OiB7XG4gICAgYmVmb3JlT3Blbj86ICgpID0+IHZvaWQ7XG4gICAgYWZ0ZXJPcGVuPzogKCkgPT4gdm9pZDtcbiAgICBiZWZvcmVDbG9zZT86ICgpID0+IHZvaWQ7XG4gICAgYWZ0ZXJDbG9zZT86ICgpID0+IHZvaWQ7XG4gIH07XG59XG5cbmV4cG9ydCBjb25zdCBEZWZhdWx0Q29ubmVjdGVkT3ZlcmxheU9wdGlvbnM6IENvbm5lY3RlZE92ZXJsYXlPcHRpb25zID0ge1xuICBoaWRkZW5DbGFzczogJ2lzLWhpZGRlbicsXG4gIGVuYWJsZUZhbGxiYWNrOiBmYWxzZSxcbiAgbWF0Y2hSZWZlcmVuY2VXaWR0aDogZmFsc2UsXG4gIG9mZnNldDogNCxcbiAgb3V0ZXJQYWRkaW5nOiAxMixcbiAgcG9zaXRpb246ICdib3R0b20nLFxuICBzdHJhdGVneTogJ2ZpeGVkJyxcbn07XG4iXX0=

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

@@ -0,0 +1,15 @@
+import { EMPTY } from 'rxjs';
+export class ConnectedOverlayRef {
+    constructor(dynamicViewRef) {
+        this.dynamicViewRef = dynamicViewRef;
+        this.element = this.dynamicViewRef.getElement();
+        this.onClose$ = this.dynamicViewRef.getContext().closed ?? EMPTY;
+    }
+    update(options) {
+        this.dynamicViewRef.update({ options: options });
+    }
+    close() {
+        this.dynamicViewRef.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGVkLW92ZXJsYXktcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9jb25uZWN0ZWQtb3ZlcmxheS9zcmMvbGliL21vZGVscy9jb25uZWN0ZWQtb3ZlcmxheS1yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUl6QyxNQUFNLE9BQU8sbUJBQW1CO0lBSTlCLFlBQTZCLGNBQWdFO1FBQWhFLG1CQUFjLEdBQWQsY0FBYyxDQUFrRDtRQUg3RSxZQUFPLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUMzQyxhQUFRLEdBQXFCLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQztJQUVFLENBQUM7SUFFMUYsTUFBTSxDQUFDLE9BQXlDO1FBQ3JELElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQWtDLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEeW5hbWljVmlld1JlZiB9IGZyb20gJ0BvZHgvYW5ndWxhci9jZGsvZHluYW1pYy12aWV3JztcbmltcG9ydCB7IEVNUFRZLCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDb25uZWN0ZWRPdmVybGF5Q29tcG9uZW50IH0gZnJvbSAnLi4vY29ubmVjdGVkLW92ZXJsYXkuY29tcG9uZW50JztcbmltcG9ydCB7IENvbm5lY3RlZE92ZXJsYXlPcHRpb25zIH0gZnJvbSAnLi9jb25uZWN0ZWQtb3ZlcmxheS1vcHRpb25zJztcblxuZXhwb3J0IGNsYXNzIENvbm5lY3RlZE92ZXJsYXlSZWYge1xuICBwdWJsaWMgcmVhZG9ubHkgZWxlbWVudCA9IHRoaXMuZHluYW1pY1ZpZXdSZWYuZ2V0RWxlbWVudCgpO1xuICBwdWJsaWMgcmVhZG9ubHkgb25DbG9zZSQ6IE9ic2VydmFibGU8dm9pZD4gPSB0aGlzLmR5bmFtaWNWaWV3UmVmLmdldENvbnRleHQoKS5jbG9zZWQgPz8gRU1QVFk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBkeW5hbWljVmlld1JlZjogRHluYW1pY1ZpZXdSZWY8dHlwZW9mIENvbm5lY3RlZE92ZXJsYXlDb21wb25lbnQ+KSB7fVxuXG4gIHB1YmxpYyB1cGRhdGUob3B0aW9uczogUGFydGlhbDxDb25uZWN0ZWRPdmVybGF5T3B0aW9ucz4pIHtcbiAgICB0aGlzLmR5bmFtaWNWaWV3UmVmLnVwZGF0ZSh7IG9wdGlvbnM6IG9wdGlvbnMgYXMgQ29ubmVjdGVkT3ZlcmxheU9wdGlvbnMgfSk7XG4gIH1cblxuICBwdWJsaWMgY2xvc2UoKTogdm9pZCB7XG4gICAgdGhpcy5keW5hbWljVmlld1JlZi5kZXN0cm95KCk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/cdk/connected-overlay/lib/models/index.mjs

@@ -0,0 +1,3 @@
+export * from './connected-overlay-options';
+export * from './connected-overlay-ref';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2Nvbm5lY3RlZC1vdmVybGF5L3NyYy9saWIvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29ubmVjdGVkLW92ZXJsYXktb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2Nvbm5lY3RlZC1vdmVybGF5LXJlZic7XG4iXX0=

package/esm2020/cdk/connected-overlay/odx-angular-cdk-connected-overlay.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY2RrLWNvbm5lY3RlZC1vdmVybGF5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9jb25uZWN0ZWQtb3ZlcmxheS9zcmMvb2R4LWFuZ3VsYXItY2RrLWNvbm5lY3RlZC1vdmVybGF5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2020/cdk/dynamic-view/lib/models/dynamic-component-ref.mjs

@@ -1,5 +1,6 @@
 import { ApplicationRef, createComponent, EnvironmentInjector } from '@angular/core';
 import { isViewContainer } from '@odx/angular/utils';
+import { deepmerge } from 'deepmerge-ts';
 export class DynamicComponentRef {
     constructor(options) {
         this.options = options;
@@ -42,8 +43,9 @@ export class DynamicComponentRef {
         return this.componentRef?.location.nativeElement ?? null;
     }
     update(context) {
-        for (const key in context) {
-            this.componentRef?.setInput(key, context[key]);
+        this.options.context = deepmerge(this.options.context, context);
+        for (const key in this.options.context) {
+            this.componentRef?.setInput(key, this.options.context[key]);
         }
     }
     getContext() {
@@ -53,4 +55,4 @@ export class DynamicComponentRef {
         return this.componentRef?.hostView ?? null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cdk/dynamic-view/lib/models/dynamic-template-ref.mjs

@@ -1,5 +1,6 @@
 import { ApplicationRef } from '@angular/core';
 import { isViewContainer } from '@odx/angular/utils';
+import { deepmerge } from 'deepmerge-ts';
 export class DynamicTemplateRef {
     constructor(options) {
         this.options = options;
@@ -25,8 +26,9 @@ export class DynamicTemplateRef {
         return this.embeddedViewRef?.rootNodes?.[0] ?? null;
     }
     update(context) {
+        this.options.context = deepmerge(this.options.context, context);
         if (this.embeddedViewRef) {
-            this.embeddedViewRef.context = context;
+            this.embeddedViewRef.context = this.options.context;
             this.detectChanges();
         }
     }
@@ -46,4 +48,4 @@ export class DynamicTemplateRef {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cdk/dynamic-view/lib/models/dynamic-view-options.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy12aWV3LW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2R5bmFtaWMtdmlldy9zcmMvbGliL21vZGVscy9keW5hbWljLXZpZXctb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IsIFN0YXRpY1Byb3ZpZGVyLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEeW5hbWljQ29udGVudCwgR2V0RHluYW1pY1ZpZXdDb250ZXh0IH0gZnJvbSAnLi4vZmFjYWRlJztcblxuZXhwb3J0IGludGVyZmFjZSBEeW5hbWljVmlld1JlbmRlcmluZ09wdGlvbnMge1xuICBpbmplY3RvcjogSW5qZWN0b3I7XG4gIHByb3ZpZGVycz86IFN0YXRpY1Byb3ZpZGVyW107XG4gIGhvc3Q/OiBWaWV3Q29udGFpbmVyUmVmIHwgRWxlbWVudDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEeW5hbWljVmlld09wdGlvbnM8VCBleHRlbmRzIER5bmFtaWNDb250ZW50PiBleHRlbmRzIER5bmFtaWNWaWV3UmVuZGVyaW5nT3B0aW9ucyB7XG4gIGNvbnRleHQ/OiBHZXREeW5hbWljVmlld0NvbnRleHQ8VD47XG4gIHByb2plY3RhYmxlTm9kZXM/OiBOb2RlW11bXTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy12aWV3LW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2R5bmFtaWMtdmlldy9zcmMvbGliL21vZGVscy9keW5hbWljLXZpZXctb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IsIFN0YXRpY1Byb3ZpZGVyLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEeW5hbWljQ29udGVudCwgR2V0RHluYW1pY1ZpZXdDb250ZXh0IH0gZnJvbSAnLi4vZmFjYWRlJztcblxuZXhwb3J0IGludGVyZmFjZSBEeW5hbWljVmlld1JlbmRlcmluZ09wdGlvbnMge1xuICBpbmplY3RvcjogSW5qZWN0b3I7XG4gIHByb3ZpZGVycz86IFN0YXRpY1Byb3ZpZGVyW107XG4gIGhvc3Q/OiBWaWV3Q29udGFpbmVyUmVmIHwgRWxlbWVudCB8IG51bGw7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRHluYW1pY1ZpZXdPcHRpb25zPFQgZXh0ZW5kcyBEeW5hbWljQ29udGVudD4gZXh0ZW5kcyBEeW5hbWljVmlld1JlbmRlcmluZ09wdGlvbnMge1xuICBjb250ZXh0PzogR2V0RHluYW1pY1ZpZXdDb250ZXh0PFQ+O1xuICBwcm9qZWN0YWJsZU5vZGVzPzogTm9kZVtdW107XG59XG4iXX0=

package/esm2020/components/accordion/lib/components/accordion-item/accordion-item.component.mjs

@@ -33,7 +33,7 @@ let AccordionItemComponent = class AccordionItemComponent extends ExpandableItem
     }
 };
 AccordionItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AccordionItemComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-AccordionItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: AccordionItemComponent, isStandalone: true, selector: "odx-accordion-item", inputs: { title: "title" }, outputs: { expandedChange: "expandedChange" }, host: { properties: { "class.is-disabled": "isDisabled", "class.odx-accordion-item--expanded": "isExpanded", "attr.id": "\"odx-accordion-item-\" + id", "attr.title": "null" } }, providers: [DisabledController.connect()], usesInheritance: true, ngImport: i0, template: "<div\n  role=\"button\"\n  class=\"odx-accordion-item__panel\"\n  [attr.id]=\"titleId\"\n  [attr.tabindex]=\"isDisabled ? -1 : 0\"\n  [attr.aria-expanded]=\"isExpanded\"\n  [attr.aria-disabled]=\"isDisabled\"\n  [attr.aria-controls]=\"slotId\"\n  (keydown.Space)=\"toggle()\"\n  (keydown.enter)=\"toggle()\"\n  (click)=\"toggle()\"\n>\n  <div *ngIf=\"title; else titleTpl\">\n    {{ title }}\n  </div>\n  <ng-template #titleTpl>\n    <ng-content select=\"odx-accordion-item-title\"></ng-content>\n  </ng-template>\n  <odx-icon class=\"odx-accordion-item__icon\" name=\"chevron-down\"></odx-icon>\n</div>\n<div\n  class=\"odx-accordion-item__slot\"\n  [attr.id]=\"slotId\"\n  [attr.aria-labelledby]=\"titleId\"\n  @expandSlotAnimation\n  (@expandSlotAnimation.done)=\"onAnimationEnd()\"\n  *ngIf=\"isExpanded\"\n>\n  <ng-content></ng-content>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name"] }], animations: [trigger('expandSlotAnimation', [transition(':enter', [useAnimation(expand)]), transition(':leave', [useAnimation(collapse)])])], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+AccordionItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: AccordionItemComponent, isStandalone: true, selector: "odx-accordion-item", inputs: { title: "title" }, outputs: { expandedChange: "expandedChange" }, host: { properties: { "class.is-disabled": "isDisabled", "class.odx-accordion-item--expanded": "isExpanded", "attr.id": "\"odx-accordion-item-\" + id", "attr.title": "null" } }, providers: [DisabledController.connect()], usesInheritance: true, ngImport: i0, template: "<div\n  role=\"button\"\n  class=\"odx-accordion-item__panel\"\n  [attr.id]=\"titleId\"\n  [attr.tabindex]=\"isDisabled ? -1 : 0\"\n  [attr.aria-expanded]=\"isExpanded\"\n  [attr.aria-disabled]=\"isDisabled || null\"\n  [attr.aria-controls]=\"slotId\"\n  (keydown.Space)=\"toggle()\"\n  (keydown.enter)=\"toggle()\"\n  (click)=\"toggle()\"\n>\n  <div *ngIf=\"title; else titleTpl\">\n    {{ title }}\n  </div>\n  <ng-template #titleTpl>\n    <ng-content select=\"odx-accordion-item-title\"></ng-content>\n  </ng-template>\n  <odx-icon class=\"odx-accordion-item__icon\" name=\"chevron-down\"></odx-icon>\n</div>\n<div\n  class=\"odx-accordion-item__slot\"\n  [attr.id]=\"slotId\"\n  [attr.aria-labelledby]=\"titleId\"\n  @expandSlotAnimation\n  (@expandSlotAnimation.done)=\"onAnimationEnd()\"\n  *ngIf=\"isExpanded\"\n>\n  <ng-content></ng-content>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name"] }], animations: [trigger('expandSlotAnimation', [transition(':enter', [useAnimation(expand)]), transition(':leave', [useAnimation(collapse)])])], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
 AccordionItemComponent = __decorate([
     CSSComponent('accordion-item')
 ], AccordionItemComponent);
@@ -45,10 +45,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                         '[class.odx-accordion-item--expanded]': 'isExpanded',
                         '[attr.id]': '"odx-accordion-item-" + id',
                         '[attr.title]': 'null',
-                    }, animations: [trigger('expandSlotAnimation', [transition(':enter', [useAnimation(expand)]), transition(':leave', [useAnimation(collapse)])])], template: "<div\n  role=\"button\"\n  class=\"odx-accordion-item__panel\"\n  [attr.id]=\"titleId\"\n  [attr.tabindex]=\"isDisabled ? -1 : 0\"\n  [attr.aria-expanded]=\"isExpanded\"\n  [attr.aria-disabled]=\"isDisabled\"\n  [attr.aria-controls]=\"slotId\"\n  (keydown.Space)=\"toggle()\"\n  (keydown.enter)=\"toggle()\"\n  (click)=\"toggle()\"\n>\n  <div *ngIf=\"title; else titleTpl\">\n    {{ title }}\n  </div>\n  <ng-template #titleTpl>\n    <ng-content select=\"odx-accordion-item-title\"></ng-content>\n  </ng-template>\n  <odx-icon class=\"odx-accordion-item__icon\" name=\"chevron-down\"></odx-icon>\n</div>\n<div\n  class=\"odx-accordion-item__slot\"\n  [attr.id]=\"slotId\"\n  [attr.aria-labelledby]=\"titleId\"\n  @expandSlotAnimation\n  (@expandSlotAnimation.done)=\"onAnimationEnd()\"\n  *ngIf=\"isExpanded\"\n>\n  <ng-content></ng-content>\n</div>\n" }]
+                    }, animations: [trigger('expandSlotAnimation', [transition(':enter', [useAnimation(expand)]), transition(':leave', [useAnimation(collapse)])])], template: "<div\n  role=\"button\"\n  class=\"odx-accordion-item__panel\"\n  [attr.id]=\"titleId\"\n  [attr.tabindex]=\"isDisabled ? -1 : 0\"\n  [attr.aria-expanded]=\"isExpanded\"\n  [attr.aria-disabled]=\"isDisabled || null\"\n  [attr.aria-controls]=\"slotId\"\n  (keydown.Space)=\"toggle()\"\n  (keydown.enter)=\"toggle()\"\n  (click)=\"toggle()\"\n>\n  <div *ngIf=\"title; else titleTpl\">\n    {{ title }}\n  </div>\n  <ng-template #titleTpl>\n    <ng-content select=\"odx-accordion-item-title\"></ng-content>\n  </ng-template>\n  <odx-icon class=\"odx-accordion-item__icon\" name=\"chevron-down\"></odx-icon>\n</div>\n<div\n  class=\"odx-accordion-item__slot\"\n  [attr.id]=\"slotId\"\n  [attr.aria-labelledby]=\"titleId\"\n  @expandSlotAnimation\n  (@expandSlotAnimation.done)=\"onAnimationEnd()\"\n  *ngIf=\"isExpanded\"\n>\n  <ng-content></ng-content>\n</div>\n" }]
         }], propDecorators: { title: [{
                 type: Input
             }], expandedChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/circular-progress/lib/circular-progress.component.mjs

@@ -2,12 +2,14 @@ import { __decorate, __metadata } from "tslib";
 import { coerceNumberProperty } from '@angular/cdk/coercion';
 import { ChangeDetectionStrategy, ChangeDetectorRef, Component, inject, Input, ViewEncapsulation } from '@angular/core';
 import { CSSComponent, CSSModifier } from '@odx/angular/internal';
-import { hasChanged, injectElement, Transform } from '@odx/angular/utils';
+import { fromElementResize$ } from '@odx/angular/rxjs';
+import { hasChanged, injectElement, Transform, untilDestroyed } from '@odx/angular/utils';
 import { CircularProgressSize } from './models/circular-progress-size';
 import * as i0 from "@angular/core";
 let CircularProgressComponent = class CircularProgressComponent {
     constructor() {
         this.changeDetector = inject(ChangeDetectorRef);
+        this.takeUntilDestroyed = untilDestroyed();
         this._value = 0;
         this.viewPortSize = 100;
         this.radius = 0;
@@ -35,7 +37,9 @@ let CircularProgressComponent = class CircularProgressComponent {
         return this._value;
     }
     ngAfterViewInit() {
-        this.updateDimensions();
+        fromElementResize$(this.element.nativeElement)
+            .pipe(this.takeUntilDestroyed())
+            .subscribe(() => this.updateDimensions());
     }
     ngOnChanges(changes) {
         if (hasChanged(changes, ['stroke', 'size'])) {
@@ -44,7 +48,10 @@ let CircularProgressComponent = class CircularProgressComponent {
     }
     updateDimensions() {
         const normalizeFactor = this.viewPortSize / (this.element.nativeElement.offsetWidth || 1);
-        this.normalizedStroke = Math.floor(normalizeFactor * this.stroke);
+        this.normalizedStroke = normalizeFactor * this.stroke;
+        if (normalizeFactor >= 3) {
+            this.normalizedStroke = Math.max(0, this.normalizedStroke - normalizeFactor);
+        }
         this.radius = this.viewPortSize / 2 - this.normalizedStroke / 2;
         this.circumference = Math.floor(2 * this.radius * Math.PI);
         this.changeDetector.detectChanges();
@@ -88,4 +95,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             }], value: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circular-progress.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/circular-progress/src/lib/circular-progress.component.ts","../../../../../../../libs/angular/components/circular-progress/src/lib/circular-progress.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty, NumberInput } from '@angular/cdk/coercion';\nimport { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, inject, Input, OnChanges, ViewEncapsulation } from '@angular/core';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { hasChanged, injectElement, NgChanges, Transform } from '@odx/angular/utils';\nimport { CircularProgressSize } from './models/circular-progress-size';\n\n@CSSComponent('circular-progress')\n@Component({\n  standalone: true,\n  selector: 'odx-circular-progress',\n  templateUrl: './circular-progress.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    '[attr.aria-valuenow]': 'ariaValueNow',\n    '[attr.aria-valuemax]': '100',\n    '[attr.aria-valuemin]': '0',\n    '[attr.role]': '\"meter\"',\n  },\n})\nexport class CircularProgressComponent implements OnChanges, AfterViewInit {\n  public static ngAcceptInputType_size: NumberInput;\n  public static ngAcceptInputType_stroke: NumberInput;\n  public static ngAcceptInputType_value: NumberInput;\n\n  private readonly changeDetector = inject(ChangeDetectorRef);\n  private _value = 0;\n\n  protected readonly viewPortSize = 100;\n  protected radius = 0;\n  protected normalizedStroke = 0;\n  protected circumference = 283;\n\n  protected get ariaValueNow(): null | number {\n    return this.indeterminate ? null : this.value;\n  }\n\n  protected get progressValue(): number {\n    return this.indeterminate ? this.circumference : Math.floor((1 - this.value / 100) * this.circumference);\n  }\n\n  public readonly element = injectElement();\n\n  @CSSModifier()\n  public indeterminate = false;\n\n  @Transform(coerceNumberProperty)\n  @Input()\n  public stroke = 4;\n\n  @CSSModifier()\n  @Input()\n  public size = CircularProgressSize.MEDIUM;\n\n  @Transform(coerceNumberProperty)\n  @Input()\n  public set value(value: unknown) {\n    const coercedValue = coerceNumberProperty(value);\n    if (coercedValue <= 100 && coercedValue >= -1) {\n      this._value = coercedValue;\n      this.indeterminate = coercedValue === -1;\n    }\n  }\n\n  public get value(): number {\n    return this._value;\n  }\n\n  public ngAfterViewInit(): void {\n    this.updateDimensions();\n  }\n\n  public ngOnChanges(changes: NgChanges<CircularProgressComponent>): void {\n    if (hasChanged(changes, ['stroke', 'size'])) {\n      this.updateDimensions();\n    }\n  }\n\n  private updateDimensions(): void {\n    const normalizeFactor = this.viewPortSize / (this.element.nativeElement.offsetWidth || 1);\n    this.normalizedStroke = Math.floor(normalizeFactor * this.stroke);\n    this.radius = this.viewPortSize / 2 - this.normalizedStroke / 2;\n    this.circumference = Math.floor(2 * this.radius * Math.PI);\n    this.changeDetector.detectChanges();\n  }\n}\n","<svg class=\"odx-circular-progress__inner\" attr.viewBox=\"0 0 {{ viewPortSize }} {{ viewPortSize }}\">\n  <circle class=\"odx-circular-progress__track\" [attr.stroke-width]=\"normalizedStroke\" [attr.r]=\"radius\" cx=\"50%\" cy=\"50%\" />\n  <circle\n    class=\"odx-circular-progress__indicator\"\n    [attr.stroke-dasharray]=\"circumference\"\n    [attr.stroke-dashoffset]=\"progressValue\"\n    [attr.stroke-width]=\"normalizedStroke\"\n    [attr.r]=\"radius\"\n    cx=\"50%\"\n    cy=\"50%\"\n  />\n</svg>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circular-progress.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/circular-progress/src/lib/circular-progress.component.ts","../../../../../../../libs/angular/components/circular-progress/src/lib/circular-progress.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty, NumberInput } from '@angular/cdk/coercion';\nimport { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, inject, Input, OnChanges, ViewEncapsulation } from '@angular/core';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { fromElementResize$ } from '@odx/angular/rxjs';\nimport { hasChanged, injectElement, NgChanges, Transform, untilDestroyed } from '@odx/angular/utils';\nimport { CircularProgressSize } from './models/circular-progress-size';\n\n@CSSComponent('circular-progress')\n@Component({\n  standalone: true,\n  selector: 'odx-circular-progress',\n  templateUrl: './circular-progress.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    '[attr.aria-valuenow]': 'ariaValueNow',\n    '[attr.aria-valuemax]': '100',\n    '[attr.aria-valuemin]': '0',\n    '[attr.role]': '\"meter\"',\n  },\n})\nexport class CircularProgressComponent implements OnChanges, AfterViewInit {\n  public static ngAcceptInputType_size: NumberInput;\n  public static ngAcceptInputType_stroke: NumberInput;\n  public static ngAcceptInputType_value: NumberInput;\n\n  private readonly changeDetector = inject(ChangeDetectorRef);\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private _value = 0;\n\n  protected readonly viewPortSize = 100;\n  protected radius = 0;\n  protected normalizedStroke = 0;\n  protected circumference = 283;\n\n  protected get ariaValueNow(): null | number {\n    return this.indeterminate ? null : this.value;\n  }\n\n  protected get progressValue(): number {\n    return this.indeterminate ? this.circumference : Math.floor((1 - this.value / 100) * this.circumference);\n  }\n\n  public readonly element = injectElement();\n\n  @CSSModifier()\n  public indeterminate = false;\n\n  @Transform(coerceNumberProperty)\n  @Input()\n  public stroke = 4;\n\n  @CSSModifier()\n  @Input()\n  public size = CircularProgressSize.MEDIUM;\n\n  @Transform(coerceNumberProperty)\n  @Input()\n  public set value(value: unknown) {\n    const coercedValue = coerceNumberProperty(value);\n    if (coercedValue <= 100 && coercedValue >= -1) {\n      this._value = coercedValue;\n      this.indeterminate = coercedValue === -1;\n    }\n  }\n\n  public get value(): number {\n    return this._value;\n  }\n\n  public ngAfterViewInit(): void {\n    fromElementResize$(this.element.nativeElement)\n      .pipe(this.takeUntilDestroyed())\n      .subscribe(() => this.updateDimensions());\n  }\n\n  public ngOnChanges(changes: NgChanges<CircularProgressComponent>): void {\n    if (hasChanged(changes, ['stroke', 'size'])) {\n      this.updateDimensions();\n    }\n  }\n\n  private updateDimensions(): void {\n    const normalizeFactor = this.viewPortSize / (this.element.nativeElement.offsetWidth || 1);\n\n    this.normalizedStroke = normalizeFactor * this.stroke;\n    if (normalizeFactor >= 3) {\n      this.normalizedStroke = Math.max(0, this.normalizedStroke - normalizeFactor);\n    }\n    this.radius = this.viewPortSize / 2 - this.normalizedStroke / 2;\n    this.circumference = Math.floor(2 * this.radius * Math.PI);\n    this.changeDetector.detectChanges();\n  }\n}\n","<svg class=\"odx-circular-progress__inner\" attr.viewBox=\"0 0 {{ viewPortSize }} {{ viewPortSize }}\">\n  <circle class=\"odx-circular-progress__track\" [attr.stroke-width]=\"normalizedStroke\" [attr.r]=\"radius\" cx=\"50%\" cy=\"50%\" />\n  <circle\n    class=\"odx-circular-progress__indicator\"\n    [attr.stroke-dasharray]=\"circumference\"\n    [attr.stroke-dashoffset]=\"progressValue\"\n    [attr.stroke-width]=\"normalizedStroke\"\n    [attr.r]=\"radius\"\n    cx=\"50%\"\n    cy=\"50%\"\n  />\n</svg>\n"]}

package/esm2020/components/dropdown/index.mjs

@@ -0,0 +1,4 @@
+export * from './lib/dropdown.directive';
+export * from './lib/dropdown.module';
+export * from './lib/models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9kcm9wZG93bi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvZHJvcGRvd24uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Ryb3Bkb3duLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMnO1xuIl19