@breadstone/mosaik-elements-angular 0.0.75 → 0.0.77

package/esm2022/Controls/Components/Overlays/Toast/ToastComponent.mjs

@@ -0,0 +1,356 @@
+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 { ToastElement } 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 ToastComponent.
+ * Use this token to provide default properties for the ToastComponent.
+ * 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 TOAST_DEFAULT_PROPS = new InjectionToken('MOSAIK_TOAST_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ * @slot actions - The actions slot.
+ */
+let ToastComponent = class ToastComponent {
+    _element;
+    _zone;
+    _closed;
+    _opened;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        this._closed = new EventEmitter();
+        this._element.on('closed', (e) => this.onEmit(this._closed, e));
+        this._opened = new EventEmitter();
+        this._element.on('opened', (e) => this.onEmit(this._opened, 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(TOAST_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get intervalTick() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.intervalTick;
+    }
+    set intervalTick(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.intervalTick = value;
+        });
+    }
+    get header() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.header;
+    }
+    set header(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.header = value;
+        });
+    }
+    get content() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.content;
+    }
+    set content(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.content = value;
+        });
+    }
+    get timeout() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.timeout;
+    }
+    set timeout(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.timeout = value;
+        });
+    }
+    get position() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.position;
+    }
+    set position(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.position = value;
+        });
+    }
+    get showProgress() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.showProgress;
+    }
+    set showProgress(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.showProgress = 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 variant() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.variant;
+    }
+    set variant(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.variant = value;
+        });
+    }
+    get formatter() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.formatter;
+    }
+    set formatter(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.formatter = value;
+        });
+    }
+    get isBusy() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isBusy;
+    }
+    set isBusy(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isBusy = value;
+        });
+    }
+    get isOpen() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.isOpen;
+    }
+    set isOpen(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.isOpen = value;
+        });
+    }
+    get hasBackdrop() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.hasBackdrop;
+    }
+    set hasBackdrop(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.hasBackdrop = value;
+        });
+    }
+    get pressEscapeToClose() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.pressEscapeToClose;
+    }
+    set pressEscapeToClose(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.pressEscapeToClose = value;
+        });
+    }
+    get clickOutsideToClose() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.clickOutsideToClose;
+    }
+    set clickOutsideToClose(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.clickOutsideToClose = value;
+        });
+    }
+    get closeable() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.closeable;
+    }
+    set closeable(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.closeable = 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 closed() {
+        return this._closed;
+    }
+    get opened() {
+        return this._opened;
+    }
+    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: ToastComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: ToastComponent, isStandalone: true, selector: "mosaik-toast", inputs: { intervalTick: "intervalTick", header: "header", content: "content", timeout: "timeout", position: "position", showProgress: "showProgress", themeName: "themeName", enter: "enter", exit: "exit", variant: "variant", formatter: "formatter", isBusy: "isBusy", isOpen: "isOpen", hasBackdrop: "hasBackdrop", pressEscapeToClose: "pressEscapeToClose", clickOutsideToClose: "clickOutsideToClose", closeable: "closeable", dir: "dir", lang: "lang" }, outputs: { closed: "closed", opened: "opened", connected: "connected", disconnected: "disconnected", changed: "changed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+ToastComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-toast', ToastElement),
+        inputs: ['intervalTick', 'header', 'content', 'timeout', 'position', 'showProgress', 'themeName', 'enter', 'exit', 'variant', 'formatter', 'isBusy', 'isOpen', 'hasBackdrop', 'pressEscapeToClose', 'clickOutsideToClose', 'closeable', 'dir', 'lang'],
+        methods: ['open', 'close', 'play', 'onEnterAnimation', 'onExitAnimation', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], ToastComponent);
+export { ToastComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: ToastComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-toast',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['intervalTick', 'header', 'content', 'timeout', 'position', 'showProgress', 'themeName', 'enter', 'exit', 'variant', 'formatter', 'isBusy', 'isOpen', 'hasBackdrop', 'pressEscapeToClose', 'clickOutsideToClose', 'closeable', 'dir', 'lang'],
+                    outputs: ['closed', 'opened', 'connected', 'disconnected', 'changed']
+                }]
+        }], ctorParameters: () => [], propDecorators: { intervalTick: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], timeout: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], showProgress: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], enter: [{
+                type: Input
+            }], exit: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], formatter: [{
+                type: Input
+            }], isBusy: [{
+                type: Input
+            }], isOpen: [{
+                type: Input
+            }], hasBackdrop: [{
+                type: Input
+            }], pressEscapeToClose: [{
+                type: Input
+            }], clickOutsideToClose: [{
+                type: Input
+            }], closeable: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], closed: [{
+                type: Output
+            }], opened: [{
+                type: Output
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideToast(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: TOAST_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ToastComponent.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Overlays/Toast/ToastComponent.ts"],"names":[],"mappings":";;;;;;;;;AAAA,iFAAiF;AACjF,mBAAmB;AACnB,yCAAyC;AACzC,qGAAqG;AACrG,oBAAoB;AACpB,iFAAiF;AAEjF,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAwB,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/M,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAa,MAAM,yBAAyB,CAAC;;AAE7E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,cAAc,CAA8B,4BAA4B,CAAC,CAAC;AAEjH;;;;GAIG;AAeI,IAAM,cAAc,GAApB,MAAM,cAAc;IACN,QAAQ,CAAe;IACvB,KAAK,CAAS;IAEd,OAAO,CAAwB;IAC/B,OAAO,CAAwB;IAC/B,UAAU,CAAwB;IAClC,aAAa,CAAwB;IACrC,QAAQ,CAAwB;IAEjD;QACI,MAAM,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;QAEnC,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,aAAa,CAAC;QACjD,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAE5B,IAAI,CAAC,OAAO,GAAG,IAAI,YAAY,EAAW,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,OAAO,GAAG,IAAI,YAAY,EAAW,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,UAAU,GAAG,IAAI,YAAY,EAAW,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,EAAW,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,QAAQ,GAAG,IAAI,YAAY,EAAW,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;QAElE,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,mBAAmB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IACxF,CAAC;IAED,IACW,YAAY;QACnB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;IACtC,CAAC;IACD,IAAW,YAAY,CAAC,KAAmC;QACvD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,MAAM;QACb,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAChC,CAAC;IACD,IAAW,MAAM,CAAC,KAA6B;QAC3C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC;QACjC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,OAAO;QACd,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;IACjC,CAAC;IACD,IAAW,OAAO,CAAC,KAA8B;QAC7C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;QAClC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,OAAO;QACd,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;IACjC,CAAC;IACD,IAAW,OAAO,CAAC,KAA8B;QAC7C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;QAClC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,QAAQ;QACf,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAClC,CAAC;IACD,IAAW,QAAQ,CAAC,KAA+B;QAC/C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC;QACnC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,YAAY;QACnB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;IACtC,CAAC;IACD,IAAW,YAAY,CAAC,KAAmC;QACvD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,SAAS;QAChB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;IACnC,CAAC;IACD,IAAW,SAAS,CAAC,KAAgC;QACjD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,KAAK;QACZ,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC/B,CAAC;IACD,IAAW,KAAK,CAAC,KAA4B;QACzC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC;QAChC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,IAAI;QACX,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC9B,CAAC;IACD,IAAW,IAAI,CAAC,KAA2B;QACvC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAC;QAC/B,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,OAAO;QACd,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;IACjC,CAAC;IACD,IAAW,OAAO,CAAC,KAA8B;QAC7C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;QAClC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,SAAS;QAChB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;IACnC,CAAC;IACD,IAAW,SAAS,CAAC,KAAgC;QACjD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,MAAM;QACb,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAChC,CAAC;IACD,IAAW,MAAM,CAAC,KAA6B;QAC3C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC;QACjC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,MAAM;QACb,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAChC,CAAC;IACD,IAAW,MAAM,CAAC,KAA6B;QAC3C,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC;QACjC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,WAAW;QAClB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACrC,CAAC;IACD,IAAW,WAAW,CAAC,KAAkC;QACrD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAC;QACtC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,kBAAkB;QACzB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;IAC5C,CAAC;IACD,IAAW,kBAAkB,CAAC,KAAyC;QACnE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAC7C,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,mBAAmB;QAC1B,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IAC7C,CAAC;IACD,IAAW,mBAAmB,CAAC,KAA0C;QACrE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,mBAAmB,GAAG,KAAK,CAAC;QAC9C,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,SAAS;QAChB,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;IACnC,CAAC;IACD,IAAW,SAAS,CAAC,KAAgC;QACjD,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,GAAG;QACV,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC7B,CAAC;IACD,IAAW,GAAG,CAAC,KAA0B;QACrC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC;QAC9B,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,IAAI;QACX,gDAAgD;QAChD,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC9B,CAAC;IACD,IAAW,IAAI,CAAC,KAA2B;QACvC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC9B,gDAAgD;YAChD,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAC;QAC/B,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IACW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IACW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IACW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,IACW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,IACW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAEM,MAAM,CAAmC,MAAe,EAAE,GAAG,IAAgD;QAChH,OAAQ,IAAI,CAAC,QAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACnD,CAAC;IAEO,MAAM,CAAI,OAAwB,EAAE,KAAY;QACpD,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;YAC/B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,IAAI,EAAE,CAAC;QACnB,CAAC;IACL,CAAC;uGArSQ,cAAc;2FAAd,cAAc,qoBAJb,2BAA2B;;AAI5B,cAAc;IAb1B,QAAQ,CAAC;QACN,qBAAqB,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC;QAChF,MAAM,EAAE,CAAC,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,CAAC;QACtP,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,CAAC;KAChI,CAAC;;GASW,cAAc,CAsS1B;;2FAtSY,cAAc;kBAR1B,SAAS;mBAAC;oBACP,QAAQ,EAAE,cAAc;oBACxB,UAAU,EAAE,IAAI;oBAChB,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE,2BAA2B;oBACrC,MAAM,EAAE,CAAC,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,CAAC;oBACtP,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,SAAS,CAAC;iBACxE;wDAgCc,YAAY;sBADtB,KAAK;gBAaK,MAAM;sBADhB,KAAK;gBAaK,OAAO;sBADjB,KAAK;gBAaK,OAAO;sBADjB,KAAK;gBAaK,QAAQ;sBADlB,KAAK;gBAaK,YAAY;sBADtB,KAAK;gBAaK,SAAS;sBADnB,KAAK;gBAaK,KAAK;sBADf,KAAK;gBAaK,IAAI;sBADd,KAAK;gBAaK,OAAO;sBADjB,KAAK;gBAaK,SAAS;sBADnB,KAAK;gBAaK,MAAM;sBADhB,KAAK;gBAaK,MAAM;sBADhB,KAAK;gBAaK,WAAW;sBADrB,KAAK;gBAaK,kBAAkB;sBAD5B,KAAK;gBAaK,mBAAmB;sBAD7B,KAAK;gBAaK,SAAS;sBADnB,KAAK;gBAaK,GAAG;sBADb,KAAK;gBAaK,IAAI;sBADd,KAAK;gBAaK,MAAM;sBADhB,MAAM;gBAMI,MAAM;sBADhB,MAAM;gBAMI,SAAS;sBADnB,MAAM;gBAMI,YAAY;sBADtB,MAAM;gBAMI,OAAO;sBADjB,MAAM;;AA4BX;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,MAAmC;IAC5D,OAAO,wBAAwB,CAAC;QAC5B;YACI,OAAO,EAAE,mBAAmB;YAC5B,QAAQ,EAAE,MAAM;SACnB;KACJ,CAAC,CAAC;AACP,CAAC","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 { ToastElement } 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 ToastComponent.\n * Use this token to provide default properties for the ToastComponent.\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 TOAST_DEFAULT_PROPS = new InjectionToken<Partial<ToastElement.Props>>('MOSAIK_TOAST_DEFAULT_PROPS');\n\n/**\n * @public\n *\n * @slot actions - The actions slot.\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-toast', ToastElement),\n    inputs: ['intervalTick', 'header', 'content', 'timeout', 'position', 'showProgress', 'themeName', 'enter', 'exit', 'variant', 'formatter', 'isBusy', 'isOpen', 'hasBackdrop', 'pressEscapeToClose', 'clickOutsideToClose', 'closeable', 'dir', 'lang'],\n    methods: ['open', 'close', 'play', 'onEnterAnimation', 'onExitAnimation', 'adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-toast',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['intervalTick', 'header', 'content', 'timeout', 'position', 'showProgress', 'themeName', 'enter', 'exit', 'variant', 'formatter', 'isBusy', 'isOpen', 'hasBackdrop', 'pressEscapeToClose', 'clickOutsideToClose', 'closeable', 'dir', 'lang'],\n    outputs: ['closed', 'opened', 'connected', 'disconnected', 'changed']\n})\nexport class ToastComponent {\n    private readonly _element: ToastElement;\n    private readonly _zone: NgZone;\n\n    private readonly _closed: EventEmitter<unknown>;\n    private readonly _opened: 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._closed = new EventEmitter<unknown>();\n        this._element.on('closed', (e) => this.onEmit(this._closed, e));\n        this._opened = new EventEmitter<unknown>();\n        this._element.on('opened', (e) => this.onEmit(this._opened, 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(TOAST_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get intervalTick(): ToastElement['intervalTick'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.intervalTick;\n    }\n    public set intervalTick(value: ToastElement['intervalTick']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.intervalTick = value;\n        });\n    }\n\n    @Input()\n    public get header(): ToastElement['header'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.header;\n    }\n    public set header(value: ToastElement['header']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.header = value;\n        });\n    }\n\n    @Input()\n    public get content(): ToastElement['content'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.content;\n    }\n    public set content(value: ToastElement['content']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.content = value;\n        });\n    }\n\n    @Input()\n    public get timeout(): ToastElement['timeout'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.timeout;\n    }\n    public set timeout(value: ToastElement['timeout']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.timeout = value;\n        });\n    }\n\n    @Input()\n    public get position(): ToastElement['position'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.position;\n    }\n    public set position(value: ToastElement['position']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.position = value;\n        });\n    }\n\n    @Input()\n    public get showProgress(): ToastElement['showProgress'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.showProgress;\n    }\n    public set showProgress(value: ToastElement['showProgress']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.showProgress = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): ToastElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: ToastElement['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(): ToastElement['enter'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.enter;\n    }\n    public set enter(value: ToastElement['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(): ToastElement['exit'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.exit;\n    }\n    public set exit(value: ToastElement['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 variant(): ToastElement['variant'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.variant;\n    }\n    public set variant(value: ToastElement['variant']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.variant = value;\n        });\n    }\n\n    @Input()\n    public get formatter(): ToastElement['formatter'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.formatter;\n    }\n    public set formatter(value: ToastElement['formatter']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.formatter = value;\n        });\n    }\n\n    @Input()\n    public get isBusy(): ToastElement['isBusy'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isBusy;\n    }\n    public set isBusy(value: ToastElement['isBusy']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isBusy = value;\n        });\n    }\n\n    @Input()\n    public get isOpen(): ToastElement['isOpen'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.isOpen;\n    }\n    public set isOpen(value: ToastElement['isOpen']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.isOpen = value;\n        });\n    }\n\n    @Input()\n    public get hasBackdrop(): ToastElement['hasBackdrop'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.hasBackdrop;\n    }\n    public set hasBackdrop(value: ToastElement['hasBackdrop']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.hasBackdrop = value;\n        });\n    }\n\n    @Input()\n    public get pressEscapeToClose(): ToastElement['pressEscapeToClose'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.pressEscapeToClose;\n    }\n    public set pressEscapeToClose(value: ToastElement['pressEscapeToClose']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.pressEscapeToClose = value;\n        });\n    }\n\n    @Input()\n    public get clickOutsideToClose(): ToastElement['clickOutsideToClose'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.clickOutsideToClose;\n    }\n    public set clickOutsideToClose(value: ToastElement['clickOutsideToClose']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.clickOutsideToClose = value;\n        });\n    }\n\n    @Input()\n    public get closeable(): ToastElement['closeable'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.closeable;\n    }\n    public set closeable(value: ToastElement['closeable']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.closeable = value;\n        });\n    }\n\n    @Input()\n    public get dir(): ToastElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: ToastElement['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(): ToastElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: ToastElement['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 closed(): EventEmitter<unknown> {\n        return this._closed;\n    }\n\n    @Output()\n    public get opened(): EventEmitter<unknown> {\n        return this._opened;\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 ToastMethodNames>(method: TMethod, ...args: Parameters<ToastComponentMethods[TMethod]>): ReturnType<ToastComponentMethods[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 ToastComponent.\n */\nexport type ToastMethodNames = 'open' | 'close' | 'play' | 'onEnterAnimation' | 'onExitAnimation' | 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for ToastComponent.\n */\nexport type ToastComponentMethods = MethodMap<ToastMethodNames>;\n\n/**\n * @public\n */\nexport function provideToast(config: Partial<ToastElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: TOAST_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}

package/esm2022/Controls/Components/Primitives/Adorners/ResizeAdorner/ResizeAdornerComponent.mjs

@@ -0,0 +1,184 @@
+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 { ResizeAdornerElement } 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 ResizeAdornerComponent.
+ * Use this token to provide default properties for the ResizeAdornerComponent.
+ * 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 RESIZE_ADORNER_DEFAULT_PROPS = new InjectionToken('MOSAIK_RESIZE_ADORNER_DEFAULT_PROPS');
+/**
+ * @public
+ *
+ * @slot  - The content of the resize adorner.
+ */
+let ResizeAdornerComponent = class ResizeAdornerComponent {
+    _element;
+    _zone;
+    _connected;
+    _disconnected;
+    _changed;
+    constructor() {
+        inject(ChangeDetectorRef).detach();
+        this._element = inject(ElementRef).nativeElement;
+        this._zone = inject(NgZone);
+        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(RESIZE_ADORNER_DEFAULT_PROPS, { optional: true }) ?? {});
+    }
+    get angle() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.angle;
+    }
+    set angle(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.angle = value;
+        });
+    }
+    get transformOrigin() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.transformOrigin;
+    }
+    set transformOrigin(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.transformOrigin = 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 disabled() {
+        // @ts-ignore - temporary fix for the type error
+        return this._element.disabled;
+    }
+    set disabled(value) {
+        this._zone.runOutsideAngular(() => {
+            // @ts-ignore - temporary fix for the type error
+            this._element.disabled = 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 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: ResizeAdornerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.6", type: ResizeAdornerComponent, isStandalone: true, selector: "mosaik-resize-adorner", inputs: { angle: "angle", transformOrigin: "transformOrigin", themeName: "themeName", disabled: "disabled", dir: "dir", lang: "lang" }, outputs: { connected: "connected", disconnected: "disconnected", changed: "changed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+ResizeAdornerComponent = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: () => customElements.define('mosaik-resize-adorner', ResizeAdornerElement),
+        inputs: ['angle', 'transformOrigin', 'themeName', 'disabled', 'dir', 'lang'],
+        methods: ['adoptStyle', 'on', 'off', 'emit', 'requestUpdate']
+    }),
+    __metadata("design:paramtypes", [])
+], ResizeAdornerComponent);
+export { ResizeAdornerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: ResizeAdornerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mosaik-resize-adorner',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['angle', 'transformOrigin', 'themeName', 'disabled', 'dir', 'lang'],
+                    outputs: ['connected', 'disconnected', 'changed']
+                }]
+        }], ctorParameters: () => [], propDecorators: { angle: [{
+                type: Input
+            }], transformOrigin: [{
+                type: Input
+            }], themeName: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }], lang: [{
+                type: Input
+            }], connected: [{
+                type: Output
+            }], disconnected: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+/**
+ * @public
+ */
+export function provideResizeAdorner(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: RESIZE_ADORNER_DEFAULT_PROPS,
+            useValue: config
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResizeAdornerComponent.js","sourceRoot":"","sources":["../../../../../../../src/Controls/Components/Primitives/Adorners/ResizeAdorner/ResizeAdornerComponent.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 { ResizeAdornerElement } 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 ResizeAdornerComponent.\n * Use this token to provide default properties for the ResizeAdornerComponent.\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 RESIZE_ADORNER_DEFAULT_PROPS = new InjectionToken<Partial<ResizeAdornerElement.Props>>('MOSAIK_RESIZE_ADORNER_DEFAULT_PROPS');\n\n/**\n * @public\n *\n * @slot  - The content of the resize adorner.\n */\n\n@ProxyCmp({\n    defineCustomElementFn: () => customElements.define('mosaik-resize-adorner', ResizeAdornerElement),\n    inputs: ['angle', 'transformOrigin', 'themeName', 'disabled', 'dir', 'lang'],\n    methods: ['adoptStyle', 'on', 'off', 'emit', 'requestUpdate']\n})\n@Component({\n    selector: 'mosaik-resize-adorner',\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: '<ng-content></ng-content>',\n    inputs: ['angle', 'transformOrigin', 'themeName', 'disabled', 'dir', 'lang'],\n    outputs: ['connected', 'disconnected', 'changed']\n})\nexport class ResizeAdornerComponent {\n    private readonly _element: ResizeAdornerElement;\n    private readonly _zone: NgZone;\n\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._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(RESIZE_ADORNER_DEFAULT_PROPS, { optional: true }) ?? {});\n    }\n\n    @Input()\n    public get angle(): ResizeAdornerElement['angle'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.angle;\n    }\n    public set angle(value: ResizeAdornerElement['angle']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.angle = value;\n        });\n    }\n\n    @Input()\n    public get transformOrigin(): ResizeAdornerElement['transformOrigin'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.transformOrigin;\n    }\n    public set transformOrigin(value: ResizeAdornerElement['transformOrigin']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.transformOrigin = value;\n        });\n    }\n\n    @Input()\n    public get themeName(): ResizeAdornerElement['themeName'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.themeName;\n    }\n    public set themeName(value: ResizeAdornerElement['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 disabled(): ResizeAdornerElement['disabled'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.disabled;\n    }\n    public set disabled(value: ResizeAdornerElement['disabled']) {\n        this._zone.runOutsideAngular(() => {\n            // @ts-ignore - temporary fix for the type error\n            this._element.disabled = value;\n        });\n    }\n\n    @Input()\n    public get dir(): ResizeAdornerElement['dir'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.dir;\n    }\n    public set dir(value: ResizeAdornerElement['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(): ResizeAdornerElement['lang'] {\n        // @ts-ignore - temporary fix for the type error\n        return this._element.lang;\n    }\n    public set lang(value: ResizeAdornerElement['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 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 ResizeAdornerMethodNames>(method: TMethod, ...args: Parameters<ResizeAdornerComponentMethods[TMethod]>): ReturnType<ResizeAdornerComponentMethods[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 ResizeAdornerComponent.\n */\nexport type ResizeAdornerMethodNames = 'adoptStyle' | 'on' | 'off' | 'emit' | 'requestUpdate';\n\n/**\n * Declares the methods interface for ResizeAdornerComponent.\n */\nexport type ResizeAdornerComponentMethods = MethodMap<ResizeAdornerMethodNames>;\n\n/**\n * @public\n */\nexport function provideResizeAdorner(config: Partial<ResizeAdornerElement.Props>): EnvironmentProviders {\n    return makeEnvironmentProviders([\n        {\n            provide: RESIZE_ADORNER_DEFAULT_PROPS,\n            useValue: config\n        }\n    ]);\n}\n"]}