@breadstone/mosaik-elements-angular 0.0.74 → 0.0.76

package/esm2022/Controls/Components/Primitives/Floating/FloatingComponent.mjs

@@ -0,0 +1,488 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';
+import { FloatingElement } from '@breadstone/mosaik-elements-foundation';
+import { applyDefaults, ProxyCmp } from '../../../../Utils/Proxy';
+import * as i0 from "@angular/core";
+/**
+ * @public
+ *
+ * Injection token for the default properties of the FloatingComponent.
+ * Use this token to provide default properties for the FloatingComponent.
+ * The properties will be applied to the component when it is created.
+ * This is useful for setting default values for properties that are not set by the user.
+ */
+export const FLOATING_DEFAULT_PROPS = new InjectionToken('MOSAIK_FLOATING_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ *
+ */
+let FloatingComponent = class FloatingComponent {
+    _element;
+    _zone;
+    _repositioned;
+    _activeChanged;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        this._repositioned = new EventEmitter();
+        this._element.on('repositioned', (e) => this.onEmit(this._repositioned, e));
+        this._activeChanged = new EventEmitter();
+        this._element.on('activeChanged', (e) => this.onEmit(this._activeChanged, e));
+        this._connected = new EventEmitter();
+        this._element.on('connected', (e) => this.onEmit(this._connected, e));
+        this._disconnected = new EventEmitter();
+        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));
+        this._changed = new EventEmitter();
+        this._element.on('changed', (e) => this.onEmit(this._changed, e));
+        applyDefaults(this._element, inject(FLOATING_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get anchor() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.anchor;
+    }
+    set anchor(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.anchor = value;
+        });
+    }
+    get active() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.active;
+    }
+    set active(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.active = value;
+        });
+    }
+    get placement() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.placement;
+    }
+    set placement(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.placement = value;
+        });
+    }
+    get strategy() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.strategy;
+    }
+    set strategy(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.strategy = value;
+        });
+    }
+    get distance() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.distance;
+    }
+    set distance(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.distance = value;
+        });
+    }
+    get skidding() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.skidding;
+    }
+    set skidding(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.skidding = value;
+        });
+    }
+    get arrow() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.arrow;
+    }
+    set arrow(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.arrow = value;
+        });
+    }
+    get arrowPlacement() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.arrowPlacement;
+    }
+    set arrowPlacement(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.arrowPlacement = value;
+        });
+    }
+    get arrowPadding() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.arrowPadding;
+    }
+    set arrowPadding(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.arrowPadding = value;
+        });
+    }
+    get flip() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.flip;
+    }
+    set flip(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.flip = value;
+        });
+    }
+    get flipFallbackPlacements() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.flipFallbackPlacements;
+    }
+    set flipFallbackPlacements(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.flipFallbackPlacements = value;
+        });
+    }
+    get flipBoundary() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.flipBoundary;
+    }
+    set flipBoundary(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.flipBoundary = value;
+        });
+    }
+    get flipPadding() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.flipPadding;
+    }
+    set flipPadding(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.flipPadding = value;
+        });
+    }
+    get flipFallbackStrategy() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.flipFallbackStrategy;
+    }
+    set flipFallbackStrategy(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.flipFallbackStrategy = value;
+        });
+    }
+    get shift() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.shift;
+    }
+    set shift(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.shift = value;
+        });
+    }
+    get shiftBoundary() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.shiftBoundary;
+    }
+    set shiftBoundary(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.shiftBoundary = value;
+        });
+    }
+    get shiftPadding() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.shiftPadding;
+    }
+    set shiftPadding(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.shiftPadding = value;
+        });
+    }
+    get autoSize() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.autoSize;
+    }
+    set autoSize(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.autoSize = value;
+        });
+    }
+    get autoSizeBoundary() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.autoSizeBoundary;
+    }
+    set autoSizeBoundary(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.autoSizeBoundary = value;
+        });
+    }
+    get autoSizePadding() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.autoSizePadding;
+    }
+    set autoSizePadding(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.autoSizePadding = value;
+        });
+    }
+    get sync() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.sync;
+    }
+    set sync(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.sync = value;
+        });
+    }
+    get maxWidth() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.maxWidth;
+    }
+    set maxWidth(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.maxWidth = value;
+        });
+    }
+    get maxHeight() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.maxHeight;
+    }
+    set maxHeight(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.maxHeight = value;
+        });
+    }
+    get isFullScreen() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isFullScreen;
+    }
+    set isFullScreen(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isFullScreen = value;
+        });
+    }
+    get themeName() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.themeName;
+    }
+    set themeName(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.themeName = value;
+        });
+    }
+    get enter() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.enter;
+    }
+    set enter(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.enter = value;
+        });
+    }
+    get exit() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.exit;
+    }
+    set exit(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.exit = value;
+        });
+    }
+    get elevation() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.elevation;
+    }
+    set elevation(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.elevation = value;
+        });
+    }
+    get dir() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.dir;
+    }
+    set dir(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.dir = value;
+        });
+    }
+    get lang() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.lang;
+    }
+    set lang(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.lang = value;
+        });
+    }
+    get repositioned() {
+        return this._repositioned;
+    }
+    get activeChanged() {
+        return this._activeChanged;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get disconnected() {
+        return this._disconnected;
+    }
+    get changed() {
+        return this._changed;
+    }
+    invoke(method, ...args) {
+        return this._element[method](...args);
+    }
+    onEmit(emitter, event) {
+        if (event instanceof CustomEvent) {
+            emitter.emit(event.detail);
+        }
+        else {
+            emitter.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: FloatingComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: FloatingComponent, isStandalone: true, selector: "mosaik-floating", inputs: { anchor: "anchor", active: "active", placement: "placement", strategy: "strategy", distance: "distance", skidding: "skidding", arrow: "arrow", arrowPlacement: "arrowPlacement", arrowPadding: "arrowPadding", flip: "flip", flipFallbackPlacements: "flipFallbackPlacements", flipBoundary: "flipBoundary", flipPadding: "flipPadding", flipFallbackStrategy: "flipFallbackStrategy", shift: "shift", shiftBoundary: "shiftBoundary", shiftPadding: "shiftPadding", autoSize: "autoSize", autoSizeBoundary: "autoSizeBoundary", autoSizePadding: "autoSizePadding", sync: "sync", maxWidth: "maxWidth", maxHeight: "maxHeight", isFullScreen: "isFullScreen", themeName: "themeName", enter: "enter", exit: "exit", elevation: "elevation", dir: "dir", lang: "lang" }, outputs: { repositioned: "repositioned", activeChanged: "activeChanged", connected: "connected", disconnected: "disconnected", changed: "changed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+FloatingComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-floating', FloatingElement),
+        inputs: ['anchor', 'active', 'placement', 'strategy', 'distance', 'skidding', 'arrow', 'arrowPlacement', 'arrowPadding', 'flip', 'flipFallbackPlacements', 'flipBoundary', 'flipPadding', 'flipFallbackStrategy', 'shift', 'shiftBoundary', 'shiftPadding', 'autoSize', 'autoSizeBoundary', 'autoSizePadding', 'sync', 'maxWidth', 'maxHeight', 'isFullScreen', 'themeName', 'enter', 'exit', 'elevation', 'dir', 'lang'],
+        methods: ['open', 'close', 'reposition', 'getScrollableElement', 'play', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], FloatingComponent);
+export { FloatingComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: FloatingComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-floating',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['anchor', 'active', 'placement', 'strategy', 'distance', 'skidding', 'arrow', 'arrowPlacement', 'arrowPadding', 'flip', 'flipFallbackPlacements', 'flipBoundary', 'flipPadding', 'flipFallbackStrategy', 'shift', 'shiftBoundary', 'shiftPadding', 'autoSize', 'autoSizeBoundary', 'autoSizePadding', 'sync', 'maxWidth', 'maxHeight', 'isFullScreen', 'themeName', 'enter', 'exit', 'elevation', 'dir', 'lang'],
+                    outputs: ['repositioned', 'activeChanged', 'connected', 'disconnected', 'changed']
+                }]
+        }], ctorParameters: () => [], propDecorators: { anchor: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], strategy: [{
+                type: Input
+            }], distance: [{
+                type: Input
+            }], skidding: [{
+                type: Input
+            }], arrow: [{
+                type: Input
+            }], arrowPlacement: [{
+                type: Input
+            }], arrowPadding: [{
+                type: Input
+            }], flip: [{
+                type: Input
+            }], flipFallbackPlacements: [{
+                type: Input
+            }], flipBoundary: [{
+                type: Input
+            }], flipPadding: [{
+                type: Input
+            }], flipFallbackStrategy: [{
+                type: Input
+            }], shift: [{
+                type: Input
+            }], shiftBoundary: [{
+                type: Input
+            }], shiftPadding: [{
+                type: Input
+            }], autoSize: [{
+                type: Input
+            }], autoSizeBoundary: [{
+                type: Input
+            }], autoSizePadding: [{
+                type: Input
+            }], sync: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], isFullScreen: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], enter: [{
+                type: Input
+            }], exit: [{
+                type: Input
+            }], elevation: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], repositioned: [{
+                type: Output
+            }], activeChanged: [{
+                type: Output
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideFloating(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: FLOATING_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FloatingComponent.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Primitives/Floating/FloatingComponent.ts"],"names":[],"mappings":"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","sourcesContent":["// ------------------------------------------------------------------------------\n// <auto-generated>\n//     This code was generated by a tool.\n//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n// </auto-generated>\n// ------------------------------------------------------------------------------\n\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EnvironmentProviders, EventEmitter, inject, InjectionToken, Input, makeEnvironmentProviders, NgZone, Output } from '@angular/core';\nimport { FloatingElement } from '@breadstone/mosaik-elements-foundation';\nimport { applyDefaults, ProxyCmp, MethodMap } from '../../../../Utils/Proxy';\n\n/**\n * @public\n *\n * Injection token for the default properties of the FloatingComponent.\n * Use this token to provide default properties for the FloatingComponent.\n * The properties will be applied to the component when it is created.\n * This is useful for setting default values for properties that are not set by the user.\n */\nexport const FLOATING_DEFAULT_PROPS = new InjectionToken<Partial<FloatingElement.Props>>('MOSAIK_FLOATING_DEFAULT_PROPS');\n\n/**\n * @public\n *\n *\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-floating', FloatingElement),\n    inputs: ['anchor', 'active', 'placement', 'strategy', 'distance', 'skidding', 'arrow', 'arrowPlacement', 'arrowPadding', 'flip', 'flipFallbackPlacements', 'flipBoundary', 'flipPadding', 'flipFallbackStrategy', 'shift', 'shiftBoundary', 'shiftPadding', 'autoSize', 'autoSizeBoundary', 'autoSizePadding', 'sync', 'maxWidth', 'maxHeight', 'isFullScreen', 'themeName', 'enter', 'exit', 'elevation', 'dir', 'lang'],\n    methods: ['open', 'close', 'reposition', 'getScrollableElement', 'play', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-floating',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['anchor', 'active', 'placement', 'strategy', 'distance', 'skidding', 'arrow', 'arrowPlacement', 'arrowPadding', 'flip', 'flipFallbackPlacements', 'flipBoundary', 'flipPadding', 'flipFallbackStrategy', 'shift', 'shiftBoundary', 'shiftPadding', 'autoSize', 'autoSizeBoundary', 'autoSizePadding', 'sync', 'maxWidth', 'maxHeight', 'isFullScreen', 'themeName', 'enter', 'exit', 'elevation', 'dir', 'lang'],\n    outputs: ['repositioned', 'activeChanged', 'connected', 'disconnected', 'changed']\n})\nexport class FloatingComponent {\n    private readonly _element: FloatingElement;\n    private readonly _zone: NgZone;\n\n    private readonly _repositioned: EventEmitter<unknown>;\n    private readonly _activeChanged: EventEmitter<unknown>;\n    private readonly _connected: EventEmitter<unknown>;\n    private readonly _disconnected: EventEmitter<unknown>;\n    private readonly _changed: EventEmitter<unknown>;\n\n    public constructor() {\n        inject(ChangeDetectorRef).detach();\n\n        this._element = inject(ElementRef).nativeElement;\n        this._zone = inject(NgZone);\n\n        this._repositioned = new EventEmitter<unknown>();\n        this._element.on('repositioned', (e) => this.onEmit(this._repositioned, e));\n        this._activeChanged = new EventEmitter<unknown>();\n        this._element.on('activeChanged', (e) => this.onEmit(this._activeChanged, e));\n        this._connected = new EventEmitter<unknown>();\n        this._element.on('connected', (e) => this.onEmit(this._connected, e));\n        this._disconnected = new EventEmitter<unknown>();\n        this._element.on('disconnected', (e) => this.onEmit(this._disconnected, e));\n        this._changed = new EventEmitter<unknown>();\n        this._element.on('changed', (e) => this.onEmit(this._changed, e));\n\n        applyDefaults(this._element, inject(FLOATING_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get anchor(): FloatingElement['anchor'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.anchor;\n    }\n    public set anchor(value: FloatingElement['anchor']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.anchor = value;\n        });\n    }\n\n    @Input()\n    public get active(): FloatingElement['active'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.active;\n    }\n    public set active(value: FloatingElement['active']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.active = value;\n        });\n    }\n\n    @Input()\n    public get placement(): FloatingElement['placement'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.placement;\n    }\n    public set placement(value: FloatingElement['placement']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.placement = value;\n        });\n    }\n\n    @Input()\n    public get strategy(): FloatingElement['strategy'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.strategy;\n    }\n    public set strategy(value: FloatingElement['strategy']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.strategy = value;\n        });\n    }\n\n    @Input()\n    public get distance(): FloatingElement['distance'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.distance;\n    }\n    public set distance(value: FloatingElement['distance']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.distance = value;\n        });\n    }\n\n    @Input()\n    public get skidding(): FloatingElement['skidding'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.skidding;\n    }\n    public set skidding(value: FloatingElement['skidding']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.skidding = value;\n        });\n    }\n\n    @Input()\n    public get arrow(): FloatingElement['arrow'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.arrow;\n    }\n    public set arrow(value: FloatingElement['arrow']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.arrow = value;\n        });\n    }\n\n    @Input()\n    public get arrowPlacement(): FloatingElement['arrowPlacement'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.arrowPlacement;\n    }\n    public set arrowPlacement(value: FloatingElement['arrowPlacement']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.arrowPlacement = value;\n        });\n    }\n\n    @Input()\n    public get arrowPadding(): FloatingElement['arrowPadding'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.arrowPadding;\n    }\n    public set arrowPadding(value: FloatingElement['arrowPadding']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.arrowPadding = value;\n        });\n    }\n\n    @Input()\n    public get flip(): FloatingElement['flip'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.flip;\n    }\n    public set flip(value: FloatingElement['flip']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.flip = value;\n        });\n    }\n\n    @Input()\n    public get flipFallbackPlacements(): FloatingElement['flipFallbackPlacements'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.flipFallbackPlacements;\n    }\n    public set flipFallbackPlacements(value: FloatingElement['flipFallbackPlacements']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.flipFallbackPlacements = value;\n        });\n    }\n\n    @Input()\n    public get flipBoundary(): FloatingElement['flipBoundary'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.flipBoundary;\n    }\n    public set flipBoundary(value: FloatingElement['flipBoundary']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.flipBoundary = value;\n        });\n    }\n\n    @Input()\n    public get flipPadding(): FloatingElement['flipPadding'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.flipPadding;\n    }\n    public set flipPadding(value: FloatingElement['flipPadding']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.flipPadding = value;\n        });\n    }\n\n    @Input()\n    public get flipFallbackStrategy(): FloatingElement['flipFallbackStrategy'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.flipFallbackStrategy;\n    }\n    public set flipFallbackStrategy(value: FloatingElement['flipFallbackStrategy']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.flipFallbackStrategy = value;\n        });\n    }\n\n    @Input()\n    public get shift(): FloatingElement['shift'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.shift;\n    }\n    public set shift(value: FloatingElement['shift']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.shift = value;\n        });\n    }\n\n    @Input()\n    public get shiftBoundary(): FloatingElement['shiftBoundary'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.shiftBoundary;\n    }\n    public set shiftBoundary(value: FloatingElement['shiftBoundary']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.shiftBoundary = value;\n        });\n    }\n\n    @Input()\n    public get shiftPadding(): FloatingElement['shiftPadding'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.shiftPadding;\n    }\n    public set shiftPadding(value: FloatingElement['shiftPadding']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.shiftPadding = value;\n        });\n    }\n\n    @Input()\n    public get autoSize(): FloatingElement['autoSize'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.autoSize;\n    }\n    public set autoSize(value: FloatingElement['autoSize']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.autoSize = value;\n        });\n    }\n\n    @Input()\n    public get autoSizeBoundary(): FloatingElement['autoSizeBoundary'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.autoSizeBoundary;\n    }\n    public set autoSizeBoundary(value: FloatingElement['autoSizeBoundary']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.autoSizeBoundary = value;\n        });\n    }\n\n    @Input()\n    public get autoSizePadding(): FloatingElement['autoSizePadding'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.autoSizePadding;\n    }\n    public set autoSizePadding(value: FloatingElement['autoSizePadding']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.autoSizePadding = value;\n        });\n    }\n\n    @Input()\n    public get sync(): FloatingElement['sync'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.sync;\n    }\n    public set sync(value: FloatingElement['sync']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.sync = value;\n        });\n    }\n\n    @Input()\n    public get maxWidth(): FloatingElement['maxWidth'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.maxWidth;\n    }\n    public set maxWidth(value: FloatingElement['maxWidth']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.maxWidth = value;\n        });\n    }\n\n    @Input()\n    public get maxHeight(): FloatingElement['maxHeight'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.maxHeight;\n    }\n    public set maxHeight(value: FloatingElement['maxHeight']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.maxHeight = value;\n        });\n    }\n\n    @Input()\n    public get isFullScreen(): FloatingElement['isFullScreen'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isFullScreen;\n    }\n    public set isFullScreen(value: FloatingElement['isFullScreen']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isFullScreen = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): FloatingElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: FloatingElement['themeName']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.themeName = value;\n        });\n    }\n\n    @Input()\n    public get enter(): FloatingElement['enter'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.enter;\n    }\n    public set enter(value: FloatingElement['enter']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.enter = value;\n        });\n    }\n\n    @Input()\n    public get exit(): FloatingElement['exit'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.exit;\n    }\n    public set exit(value: FloatingElement['exit']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.exit = value;\n        });\n    }\n\n    @Input()\n    public get elevation(): FloatingElement['elevation'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.elevation;\n    }\n    public set elevation(value: FloatingElement['elevation']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.elevation = value;\n        });\n    }\n\n    @Input()\n    public get dir(): FloatingElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: FloatingElement['dir']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.dir = value;\n        });\n    }\n\n    @Input()\n    public get lang(): FloatingElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: FloatingElement['lang']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.lang = value;\n        });\n    }\n\n    @Output()\n    public get repositioned(): EventEmitter<unknown> {\n        return this._repositioned;\n    }\n\n    @Output()\n    public get activeChanged(): EventEmitter<unknown> {\n        return this._activeChanged;\n    }\n\n    @Output()\n    public get connected(): EventEmitter<unknown> {\n        return this._connected;\n    }\n\n    @Output()\n    public get disconnected(): EventEmitter<unknown> {\n        return this._disconnected;\n    }\n\n    @Output()\n    public get changed(): EventEmitter<unknown> {\n        return this._changed;\n    }\n\n    public invoke<TMethod extends FloatingMethodNames>(method: TMethod, ...args: Parameters<FloatingComponentMethods[TMethod]>): ReturnType<FloatingComponentMethods[TMethod]> {\n        return (this._element as any)[method](...args);\n    }\n\n    private onEmit<T>(emitter: EventEmitter<T>, event: Event): void {\n        if (event instanceof CustomEvent) {\n            emitter.emit(event.detail);\n        } else {\n            emitter.emit();\n        }\n    }\n}\n\n/**\n * Declares the methods available on FloatingComponent.\n */\nexport type FloatingMethodNames = 'open' | 'close' | 'reposition' | 'getScrollableElement' | 'play' | 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for FloatingComponent.\n */\nexport type FloatingComponentMethods = MethodMap<FloatingMethodNames>;\n\n/**\n * @public\n */\nexport function provideFloating(config: Partial<FloatingElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: FLOATING_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}