@ngutil/floating 0.0.27

package/README.md

@@ -0,0 +1,23 @@
+# floating
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test floating` to execute the unit tests.
+
+
+## Plan
+
+```typescript
+floating.showComponent(Component, new Modal({
+    backdrop: {click: "close | hide", cut: element},
+    escape: "close | hide",
+}));
+floating.showComponent(Component, new Toast({}));
+floating.showComponent(Component, new Tip({anchor: {ref: element}})).subscribe(event => {
+    if (event === "done") {
+        // ...
+    }
+})
+```

package/esm2022/floating/floating-ref.mjs

@@ -0,0 +1,81 @@
+import { Inject, Injectable, InjectionToken } from "@angular/core";
+import { EMPTY, filter, map, merge, ReplaySubject, shareReplay, takeUntil } from "rxjs";
+import { StateChain } from "@ngutil/common";
+import { ContainerRef } from "../layer/container-ref";
+import { LayerService } from "../layer/layer.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../layer/layer.service";
+import * as i2 from "../layer/container-ref";
+export const TRAITS = new InjectionToken("TRAITS");
+export class FloatingRef {
+    #traits;
+    #untilCleanup;
+    #untilDisposed;
+    constructor(layerSvc, container, traits) {
+        this.layerSvc = layerSvc;
+        this.container = container;
+        this.channel = new ReplaySubject(1);
+        this.state = new StateChain({
+            init: {},
+            showing: {},
+            shown: {},
+            closing: { cancellable: false, order: "sequential" },
+            disposing: { cancellable: false },
+            disposed: { cancellable: false, order: "sequential" },
+            cleanup: { cancellable: false, order: "sequential" }
+        });
+        this.#traits = {};
+        this.#untilCleanup = this.state.current$.pipe(filter(state => state === "cleanup"), shareReplay(1));
+        this.#untilDisposed = this.state.current$.pipe(filter(state => state === "cleanup"), shareReplay(1));
+        this.#traits = traits;
+        this.traitState$ = this.#traitState().pipe(shareReplay(1));
+        const sub = this.state.current$.subscribe(state => {
+            this.channel.next({ type: state });
+        });
+        this.state.on("init", () => {
+            this.traitState$.pipe(takeUntil(this.#untilCleanup)).subscribe();
+        });
+        this.state.on("disposed", () => {
+            sub.unsubscribe();
+        });
+        this.state.control(container.state);
+    }
+    show() {
+        return this.state.run(["init", "showing", "shown"]);
+    }
+    hide() {
+        return this.state.run(["disposing", "disposed", "cleanup"]);
+    }
+    close() {
+        return this.state.run(["closing", "disposing", "disposed", "cleanup"]);
+    }
+    watchTrait(name) {
+        return this.traitState$.pipe(takeUntil(this.#untilDisposed), filter(event => event.name === name), map(event => event.data), shareReplay(1));
+    }
+    #traitState() {
+        const src = [];
+        for (const [k, v] of Object.entries(this.#traits)) {
+            src.push(v.connect(this).pipe(takeUntil(this.#untilCleanup), map(result => {
+                return { name: k, data: result };
+            })));
+        }
+        if (src.length === 0) {
+            return EMPTY;
+        }
+        else if (src.length === 1) {
+            return src[0];
+        }
+        else {
+            return merge(...src);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingRef, deps: [{ token: i1.LayerService }, { token: i2.ContainerRef }, { token: TRAITS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingRef }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingRef, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.LayerService }, { type: i2.ContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRAITS]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floating-ref.js","sourceRoot":"","sources":["../../../../../packages/floating/src/floating/floating-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAElE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAc,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,MAAM,CAAA;AAEnG,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;;;;AAKrD,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,cAAc,CAAS,QAAQ,CAAC,CAAA;AAa1D,MAAM,OAAO,WAAW;IAaX,OAAO,CAAa;IAGpB,aAAa,CAGrB;IAEQ,cAAc,CAGtB;IAED,YACa,QAAsB,EACtB,SAAuB,EAChB,MAAc;QAFrB,aAAQ,GAAR,QAAQ,CAAc;QACtB,cAAS,GAAT,SAAS,CAAc;QA3B3B,YAAO,GAAG,IAAI,aAAa,CAAI,CAAC,CAAC,CAAA;QAEjC,UAAK,GAAG,IAAI,UAAU,CAAC;YAC5B,IAAI,EAAE,EAAE;YACR,OAAO,EAAE,EAAE;YACX,KAAK,EAAE,EAAE;YACT,OAAO,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE;YACpD,SAAS,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE;YACjC,QAAQ,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE;YACrD,OAAO,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE;SACvD,CAAC,CAAA;QAEO,YAAO,GAAW,EAAE,CAAA;QAGpB,kBAAa,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAC7C,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,EACpC,WAAW,CAAC,CAAC,CAAC,CACjB,CAAA;QAEQ,mBAAc,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAC9C,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,EACpC,WAAW,CAAC,CAAC,CAAC,CACjB,CAAA;QAOG,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;QAE1D,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAS,CAAC,CAAA;QAC7C,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;YACvB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,EAAE,CAAA;QACpE,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE;YAC3B,GAAG,CAAC,WAAW,EAAE,CAAA;QACrB,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;IACvC,CAAC;IAED,IAAI;QACA,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;IACvD,CAAC;IAED,IAAI;QACA,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAA;IAC/D,CAAC;IAED,KAAK;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAA;IAC1E,CAAC;IAED,UAAU,CAAI,IAAY;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CACxB,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,EAC9B,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EACpC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAS,CAAC,EAC7B,WAAW,CAAC,CAAC,CAAC,CACjB,CAAA;IACL,CAAC;IAED,WAAW;QACP,MAAM,GAAG,GAAG,EAAE,CAAA;QAEd,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAChD,GAAG,CAAC,IAAI,CACJ,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAChB,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,MAAM,CAAC,EAAE;gBACT,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;YACpC,CAAC,CAAC,CACL,CACJ,CAAA;QACL,CAAC;QAED,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,KAAK,CAAA;QAChB,CAAC;aAAM,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC;aAAM,CAAC;YACJ,OAAO,KAAK,CAAC,GAAG,GAAG,CAAC,CAAA;QACxB,CAAC;IACL,CAAC;8GAxFQ,WAAW,0EA6BR,MAAM;kHA7BT,WAAW;;2FAAX,WAAW;kBADvB,UAAU;;0BA8BF,MAAM;2BAAC,MAAM","sourcesContent":["import { Inject, Injectable, InjectionToken } from \"@angular/core\"\n\nimport { EMPTY, filter, map, merge, Observable, ReplaySubject, shareReplay, takeUntil } from \"rxjs\"\n\nimport { StateChain } from \"@ngutil/common\"\n\nimport { ContainerRef } from \"../layer/container-ref\"\nimport { LayerService } from \"../layer/layer.service\"\nimport { FloatingTrait } from \"./traits/_base\"\n\nexport type Traits = { [key: string]: FloatingTrait }\n\nexport const TRAITS = new InjectionToken<Traits>(\"TRAITS\")\n\nexport interface FloatingChannel {\n    type: string\n    data?: any\n}\n\nexport interface FloatingTraitEvent {\n    name: string\n    data: object\n}\n\n@Injectable()\nexport class FloatingRef<C extends FloatingChannel = FloatingChannel, T extends HTMLElement = HTMLElement> {\n    readonly channel = new ReplaySubject<C>(1)\n\n    readonly state = new StateChain({\n        init: {},\n        showing: {},\n        shown: {},\n        closing: { cancellable: false, order: \"sequential\" },\n        disposing: { cancellable: false },\n        disposed: { cancellable: false, order: \"sequential\" },\n        cleanup: { cancellable: false, order: \"sequential\" }\n    })\n\n    readonly #traits: Traits = {}\n    readonly traitState$: Observable<FloatingTraitEvent>\n\n    readonly #untilCleanup = this.state.current$.pipe(\n        filter(state => state === \"cleanup\"),\n        shareReplay(1)\n    )\n\n    readonly #untilDisposed = this.state.current$.pipe(\n        filter(state => state === \"cleanup\"),\n        shareReplay(1)\n    )\n\n    constructor(\n        readonly layerSvc: LayerService,\n        readonly container: ContainerRef,\n        @Inject(TRAITS) traits: Traits\n    ) {\n        this.#traits = traits\n        this.traitState$ = this.#traitState().pipe(shareReplay(1))\n\n        const sub = this.state.current$.subscribe(state => {\n            this.channel.next({ type: state } as any)\n        })\n        this.state.on(\"init\", () => {\n            this.traitState$.pipe(takeUntil(this.#untilCleanup)).subscribe()\n        })\n        this.state.on(\"disposed\", () => {\n            sub.unsubscribe()\n        })\n        this.state.control(container.state)\n    }\n\n    show() {\n        return this.state.run([\"init\", \"showing\", \"shown\"])\n    }\n\n    hide() {\n        return this.state.run([\"disposing\", \"disposed\", \"cleanup\"])\n    }\n\n    close() {\n        return this.state.run([\"closing\", \"disposing\", \"disposed\", \"cleanup\"])\n    }\n\n    watchTrait<T>(name: string): Observable<T> {\n        return this.traitState$.pipe(\n            takeUntil(this.#untilDisposed),\n            filter(event => event.name === name),\n            map(event => event.data as T),\n            shareReplay(1)\n        )\n    }\n\n    #traitState(): Observable<FloatingTraitEvent> {\n        const src = []\n\n        for (const [k, v] of Object.entries(this.#traits)) {\n            src.push(\n                v.connect(this).pipe(\n                    takeUntil(this.#untilCleanup),\n                    map(result => {\n                        return { name: k, data: result }\n                    })\n                )\n            )\n        }\n\n        if (src.length === 0) {\n            return EMPTY\n        } else if (src.length === 1) {\n            return src[0]\n        } else {\n            return merge(...src)\n        }\n    }\n}\n"]}

package/esm2022/floating/floating.service.mjs

@@ -0,0 +1,123 @@
+import { inject, Injectable, TemplateRef } from "@angular/core";
+import { Observable } from "rxjs";
+import { LayerService } from "../layer/layer.service";
+import { FloatingRef, TRAITS } from "./floating-ref";
+import { position } from "./traits/position";
+import * as i0 from "@angular/core";
+// export type FloatingTrait = (...args: any[]) => (traits: object) => Observable<object>
+export class FloatingFactory {
+    constructor(layer) {
+        this.layer = layer;
+        this.traits = {};
+        this.subscribe = (...args) => this.show().subscribe(...args);
+    }
+    trait(...traits) {
+        for (const trait of traits) {
+            if (Array.isArray(trait)) {
+                this.trait(...trait);
+            }
+            else {
+                this.traits[trait.name] = trait;
+            }
+        }
+        return this;
+    }
+    show() {
+        return new Observable((dest) => {
+            let disposed = false;
+            const ref = this.create();
+            const channelSub = ref.channel.subscribe(event => {
+                dest.next(event);
+                if (event.type === "disposed") {
+                    disposed = true;
+                    dest.complete();
+                }
+            });
+            const showSub = ref.show().subscribe();
+            return () => {
+                showSub.unsubscribe();
+                channelSub.unsubscribe();
+                if (!disposed) {
+                    const dispose$ = ref.channel.subscribe(event => {
+                        if (event.type === "disposed") {
+                            hideSub.unsubscribe();
+                            dispose$.unsubscribe();
+                        }
+                    });
+                    const hideSub = ref.hide().subscribe();
+                }
+            };
+        });
+    }
+    providers(providers) {
+        if (!providers) {
+            providers = [];
+        }
+        providers = [
+            ...providers,
+            { provide: TRAITS, useValue: this.traits },
+            { provide: LayerService, useValue: this.layer },
+            FloatingRef
+        ];
+        return providers;
+    }
+    position(options) {
+        return this.trait(position(options));
+    }
+}
+export class FloatingTemplateFactory extends FloatingFactory {
+    constructor(layer, tpl, options) {
+        super(layer);
+        this.tpl = tpl;
+        this.options = options;
+    }
+    create() {
+        const options = { ...this.options };
+        options.providers = this.providers(options.providers);
+        const container = this.layer.newTemplatePortal(this.tpl, options);
+        return container.injector.get(FloatingRef);
+    }
+}
+export class FloatingComponentFactory extends FloatingFactory {
+    constructor(layer, component, options) {
+        super(layer);
+        this.component = component;
+        this.options = options;
+    }
+    create() {
+        const options = { ...this.options };
+        options.providers = this.providers(options.providers);
+        const container = this.layer.newComponentPortal(this.component, options);
+        return container.injector.get(FloatingRef);
+    }
+}
+/**
+ * @example
+ * ```typescript
+ * class SomeComponent {}
+ *
+ * class SomeList {
+ *      readonly floating = inject(FloatingService)
+ *
+ *      showComponent() {
+ *          this.floating.from(SomeComponent).traits(position(), backdrop()).subscribe()
+ *      }
+ * ```
+ */
+export class FloatingService {
+    #layer = inject(LayerService);
+    from(value, opts) {
+        if (value instanceof TemplateRef) {
+            return new FloatingTemplateFactory(this.#layer, value, opts);
+        }
+        else {
+            return new FloatingComponentFactory(this.#layer, value, opts);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: FloatingService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floating.service.js","sourceRoot":"","sources":["../../../../../packages/floating/src/floating/floating.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from \"@angular/cdk/portal\"\nimport { inject, Injectable, Provider, TemplateRef } from \"@angular/core\"\n\nimport { Observable, Subscriber } from \"rxjs\"\n\nimport { LayerService } from \"../layer/layer.service\"\nimport { ComponentPortalOptions, TemplatePortalOptions } from \"../layer/portal-ref\"\nimport { FloatingChannel, FloatingRef, TRAITS } from \"./floating-ref\"\nimport { type FloatingTrait } from \"./traits/_base\"\nimport { type FloatingPositionOptions, position } from \"./traits/position\"\n\n// export type FloatingTrait = (...args: any[]) => (traits: object) => Observable<object>\n\nexport abstract class FloatingFactory {\n    protected readonly traits: { [key: string]: FloatingTrait } = {}\n\n    constructor(protected readonly layer: LayerService) {}\n\n    trait(...traits: Array<FloatingTrait | FloatingTrait[]>) {\n        for (const trait of traits) {\n            if (Array.isArray(trait)) {\n                this.trait(...trait)\n            } else {\n                this.traits[trait.name] = trait\n            }\n        }\n\n        return this\n    }\n\n    show(): Observable<FloatingChannel> {\n        return new Observable((dest: Subscriber<FloatingChannel>) => {\n            let disposed = false\n\n            const ref = this.create()\n            const channelSub = ref.channel.subscribe(event => {\n                dest.next(event)\n                if (event.type === \"disposed\") {\n                    disposed = true\n                    dest.complete()\n                }\n            })\n\n            const showSub = ref.show().subscribe()\n\n            return () => {\n                showSub.unsubscribe()\n                channelSub.unsubscribe()\n                if (!disposed) {\n                    const dispose$ = ref.channel.subscribe(event => {\n                        if (event.type === \"disposed\") {\n                            hideSub.unsubscribe()\n                            dispose$.unsubscribe()\n                        }\n                    })\n                    const hideSub = ref.hide().subscribe()\n                }\n            }\n        })\n    }\n\n    subscribe = (...args: any[]) => this.show().subscribe(...args)\n\n    protected providers(providers?: Provider[]): Provider[] {\n        if (!providers) {\n            providers = []\n        }\n\n        providers = [\n            ...providers,\n            { provide: TRAITS, useValue: this.traits },\n            { provide: LayerService, useValue: this.layer },\n            FloatingRef\n        ]\n\n        return providers\n    }\n\n    protected abstract create(): FloatingRef<FloatingChannel>\n\n    position(options: FloatingPositionOptions) {\n        return this.trait(position(options))\n    }\n}\n\nexport class FloatingTemplateFactory<T extends object> extends FloatingFactory {\n    constructor(\n        layer: LayerService,\n        public readonly tpl: TemplateRef<T>,\n        public readonly options: TemplatePortalOptions<T>\n    ) {\n        super(layer)\n    }\n\n    protected override create(): FloatingRef<FloatingChannel> {\n        const options: TemplatePortalOptions<T> = { ...this.options }\n        options.providers = this.providers(options.providers)\n        const container = this.layer.newTemplatePortal(this.tpl, options)\n        return container.injector.get(FloatingRef)\n    }\n}\n\nexport class FloatingComponentFactory<T extends ComponentType<any>> extends FloatingFactory {\n    constructor(\n        layer: LayerService,\n        public readonly component: T,\n        public readonly options: ComponentPortalOptions<T>\n    ) {\n        super(layer)\n    }\n\n    protected override create(): FloatingRef<FloatingChannel> {\n        const options: ComponentPortalOptions<T> = { ...this.options }\n        options.providers = this.providers(options.providers)\n        const container = this.layer.newComponentPortal(this.component, options)\n        return container.injector.get(FloatingRef)\n    }\n}\n\n/**\n * @example\n * ```typescript\n * class SomeComponent {}\n *\n * class SomeList {\n *      readonly floating = inject(FloatingService)\n *\n *      showComponent() {\n *          this.floating.from(SomeComponent).traits(position(), backdrop()).subscribe()\n *      }\n * ```\n */\n@Injectable()\nexport class FloatingService {\n    readonly #layer = inject(LayerService)\n    // readonly parent = inject(FloatingRef, { skipSelf: true, optional: true })\n\n    from<T extends ComponentType<any>>(component: T, opts?: ComponentPortalOptions<T>): FloatingComponentFactory<T>\n\n    from<T extends object>(tpl: TemplateRef<T>, opts?: TemplatePortalOptions<T>): FloatingTemplateFactory<T>\n\n    from<T>(value: ComponentType<T> | TemplateRef<T>, opts: any): FloatingFactory {\n        if (value instanceof TemplateRef) {\n            return new FloatingTemplateFactory(this.#layer, value as any, opts)\n        } else {\n            return new FloatingComponentFactory(this.#layer, value as any, opts)\n        }\n    }\n}\n"]}

package/esm2022/floating/index.mjs

@@ -0,0 +1,4 @@
+export * from "./traits";
+export * from "./floating-ref";
+export * from "./floating.service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9mbG9hdGluZy9zcmMvZmxvYXRpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUE7QUFDeEIsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLG9CQUFvQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vdHJhaXRzXCJcbmV4cG9ydCAqIGZyb20gXCIuL2Zsb2F0aW5nLXJlZlwiXG5leHBvcnQgKiBmcm9tIFwiLi9mbG9hdGluZy5zZXJ2aWNlXCJcbiJdfQ==

package/esm2022/floating/traits/_base.mjs

@@ -0,0 +1,3 @@
+export class FloatingTrait {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2Jhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9mbG9hdGluZy9zcmMvZmxvYXRpbmcvdHJhaXRzL19iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sT0FBZ0IsYUFBYTtDQUlsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tIFwicnhqc1wiXG5cbmltcG9ydCB0eXBlIHsgRmxvYXRpbmdSZWYgfSBmcm9tIFwiLi4vZmxvYXRpbmctcmVmXCJcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZsb2F0aW5nVHJhaXQ8VCA9IGFueT4ge1xuICAgIGFic3RyYWN0IHJlYWRvbmx5IG5hbWU6IHN0cmluZ1xuXG4gICAgYWJzdHJhY3QgY29ubmVjdChmbG9hdGluZ1JlZjogRmxvYXRpbmdSZWY8YW55Pik6IE9ic2VydmFibGU8VD5cbn1cbiJdfQ==

package/esm2022/floating/traits/index.mjs

@@ -0,0 +1,3 @@
+export * from "./position";
+export * from "./position-calc";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9mbG9hdGluZy9zcmMvZmxvYXRpbmcvdHJhaXRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFBO0FBQzFCLGNBQWMsaUJBQWlCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9wb3NpdGlvblwiXG5leHBvcnQgKiBmcm9tIFwiLi9wb3NpdGlvbi1jYWxjXCJcbiJdfQ==

package/esm2022/floating/traits/position-calc.mjs

@@ -0,0 +1,17 @@
+export function computePosition({ floating, anchor, placement, options }) {
+    // TODO: jelenleg csak center van
+    const maxWidth = placement.width;
+    const maxHeight = placement.height;
+    const cf = {
+        current: {
+            x: (maxWidth - floating.width) / 2,
+            y: (maxHeight - floating.height) / 2,
+            width: Math.min(maxHeight, floating.width),
+            height: Math.min(maxHeight, floating.height)
+        },
+        max: { width: maxWidth, height: maxHeight },
+        min: { width: 0, height: 0 }
+    };
+    return { floating: cf };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/floating/traits/position.mjs

@@ -0,0 +1,71 @@
+import { ElementRef } from "@angular/core";
+import { combineLatest, Observable } from "rxjs";
+import { DimensionWatcher, RectWatcher } from "@ngutil/style";
+import { FloatingTrait } from "./_base";
+import { computePosition } from "./position-calc";
+export class FloatingAnchorRef extends ElementRef {
+}
+export class FloatingPlacementRef extends ElementRef {
+}
+export class PositionTrait extends FloatingTrait {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.name = "position";
+        if (!options.anchor) {
+            options.anchor = { ref: "viewport", align: "center middle" };
+        }
+        if (!options.placement) {
+            options.placement = { ref: "viewport" };
+        }
+    }
+    connect(floatingRef) {
+        return new Observable((dest) => {
+            const injector = floatingRef.container.injector;
+            const dimWatcher = injector.get(DimensionWatcher);
+            const rectWatcher = injector.get(RectWatcher);
+            const watches = {
+                floating: dimWatcher.watch(floatingRef.container, "border-box"),
+                anchor: refWatcher(rectWatcher, this.options.anchor.ref, floatingRef),
+                placement: refWatcher(rectWatcher, this.options.placement.ref, floatingRef)
+            };
+            return combineLatest(watches).subscribe(({ floating, anchor, placement }) => {
+                const res = new FloatingPosition(this.options, floating, anchor, placement);
+                res.apply(floatingRef);
+                dest.next(res);
+            });
+        });
+    }
+}
+function refWatcher(rectWatcher, ref, floatingRef) {
+    if (ref === "layer") {
+        return rectWatcher.watch(floatingRef.layerSvc.root, "border-box");
+    }
+    else if (ref === "viewport" || ref instanceof Window) {
+        return rectWatcher.watch(window, "border-box");
+    }
+    else {
+        return rectWatcher.watch(ref, "border-box");
+    }
+}
+export function position(options) {
+    return new PositionTrait(options);
+}
+export class FloatingPosition {
+    constructor(options, floating, anchor, placement) {
+        this.options = options;
+        this.floating = floating;
+        this.anchor = anchor;
+        this.placement = placement;
+        this.computed = computePosition({ floating, anchor, placement, options });
+    }
+    apply(floatingRef) {
+        if (this.computed == null) {
+            return;
+        }
+        const floatingEl = floatingRef.container.nativeElement;
+        floatingEl.style.left = `${this.computed.floating.current.x}px`;
+        floatingEl.style.top = `${this.computed.floating.current.y}px`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"position.js","sourceRoot":"","sources":["../../../../../../packages/floating/src/floating/traits/position.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef } from \"@angular/core\"\n\nimport { combineLatest, Observable, Subscriber } from \"rxjs\"\n\nimport { ElementInput } from \"@ngutil/common\"\nimport { AlignmentInput, Dimension, DimensionWatcher, Rect, RectWatcher, SidesInput } from \"@ngutil/style\"\n\nimport { LayerService } from \"../../layer/layer.service\"\nimport { FloatingRef } from \"../floating-ref\"\nimport { FloatingTrait } from \"./_base\"\nimport { ComputedPositon, computePosition } from \"./position-calc\"\n\nexport type FloatingTargetElementRef = ElementInput | Window | \"layer\" | \"viewport\"\n\nexport interface FloatingAlign {\n    align?: AlignmentInput\n}\n\nexport interface FloatingAnchorPosition extends FloatingAlign {\n    margin?: SidesInput\n}\n\nexport interface FloatingAnchor extends FloatingAnchorPosition {\n    ref: FloatingTargetElementRef\n}\n\nexport class FloatingAnchorRef<T extends Node> extends ElementRef<T> {}\n\nexport interface FloatingContentPosition extends FloatingAlign {\n    margin?: SidesInput\n}\n\nexport interface FloatingPlacementPosition {\n    padding?: SidesInput\n}\n\nexport interface FloatingPlacement extends FloatingPlacementPosition {\n    ref: FloatingTargetElementRef\n}\n\nexport class FloatingPlacementRef<T extends LayerService[\"root\"][\"nativeElement\"]> extends ElementRef<T> {}\n\nexport interface FloatingPositionOptions {\n    anchor?: FloatingAnchor\n    content?: FloatingContentPosition\n    placement?: FloatingPlacement\n}\n\ntype Watches = {\n    floating: Observable<Dimension>\n    anchor: Observable<Rect>\n    placement: Observable<Rect>\n}\n\nexport class PositionTrait extends FloatingTrait<FloatingPosition> {\n    name = \"position\"\n\n    constructor(readonly options: FloatingPositionOptions) {\n        super()\n\n        if (!options.anchor) {\n            options.anchor = { ref: \"viewport\", align: \"center middle\" }\n        }\n\n        if (!options.placement) {\n            options.placement = { ref: \"viewport\" }\n        }\n    }\n\n    connect(floatingRef: FloatingRef<any>): Observable<FloatingPosition> {\n        return new Observable((dest: Subscriber<FloatingPosition>) => {\n            const injector = floatingRef.container.injector\n            const dimWatcher = injector.get(DimensionWatcher)\n            const rectWatcher = injector.get(RectWatcher)\n\n            const watches: Watches = {\n                floating: dimWatcher.watch(floatingRef.container, \"border-box\"),\n                anchor: refWatcher(rectWatcher, this.options.anchor!.ref, floatingRef),\n                placement: refWatcher(rectWatcher, this.options.placement!.ref, floatingRef)\n            }\n\n            return combineLatest(watches).subscribe(({ floating, anchor, placement }) => {\n                const res = new FloatingPosition(this.options, floating, anchor, placement)\n                res.apply(floatingRef)\n                dest.next(res)\n            })\n        })\n    }\n}\n\nfunction refWatcher(rectWatcher: RectWatcher, ref: FloatingTargetElementRef, floatingRef: FloatingRef<any>) {\n    if (ref === \"layer\") {\n        return rectWatcher.watch(floatingRef.layerSvc.root, \"border-box\")\n    } else if (ref === \"viewport\" || ref instanceof Window) {\n        return rectWatcher.watch(window, \"border-box\")\n    } else {\n        return rectWatcher.watch(ref, \"border-box\")\n    }\n}\n\nexport function position(options: FloatingPositionOptions) {\n    return new PositionTrait(options)\n}\n\nexport class FloatingPosition {\n    readonly computed?: ComputedPositon\n    constructor(\n        readonly options: FloatingPositionOptions,\n        readonly floating: Dimension,\n        readonly anchor: Rect,\n        readonly placement: Rect\n    ) {\n        this.computed = computePosition({ floating, anchor, placement, options })\n    }\n\n    apply(floatingRef: FloatingRef) {\n        if (this.computed == null) {\n            return\n        }\n\n        const floatingEl = floatingRef.container.nativeElement\n        floatingEl.style.left = `${this.computed.floating.current.x}px`\n        floatingEl.style.top = `${this.computed.floating.current.y}px`\n    }\n}\n"]}

package/esm2022/index.mjs

@@ -0,0 +1,3 @@
+export * from "./floating";
+export * from "./layer";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9mbG9hdGluZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUE7QUFDMUIsY0FBYyxTQUFTLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9mbG9hdGluZ1wiXG5leHBvcnQgKiBmcm9tIFwiLi9sYXllclwiXG4iXX0=

package/esm2022/layer/backdrop-ref.mjs

@@ -0,0 +1,50 @@
+import { ChildRef } from "./child-ref";
+export class BackdropRef extends ChildRef {
+    static from(cover, injector, options) {
+        const ref = new BackdropRef(document.createElement("div"), cover, injector, options);
+        // TODO: kérdéses
+        // options.under.state.control(ref.state)
+        return ref;
+    }
+    #coverSub;
+    set visible(visible) {
+        if (this.#visible !== visible) {
+            this.#visible = visible;
+            this.nativeElement.style.visibility = visible ? "visible" : "hidden";
+        }
+    }
+    get visible() {
+        return this.#visible;
+    }
+    #visible = true;
+    constructor(nativeElement, coverSvc, injector, options) {
+        super(nativeElement);
+        this.coverSvc = coverSvc;
+        this.injector = injector;
+        this.options = options;
+        nativeElement.style.position = "absolute";
+        nativeElement.style.top =
+            nativeElement.style.right =
+                nativeElement.style.bottom =
+                    nativeElement.style.left =
+                        "0px";
+        this.under = options.under;
+        if (options.type === "solid") {
+            this.#coverSub = this.coverSvc.solid({ container: nativeElement, color: options.color }).subscribe();
+            this.group = `${options.color === "transparent" ? "transparent" : "solid"}`;
+        }
+        else if (options.type === "crop") {
+            this.#coverSub = this.coverSvc
+                .crop({ container: nativeElement, color: options.color, crop: options.crop })
+                .subscribe();
+        }
+    }
+    show() {
+        return this.state.run(["showing", "shown"]);
+    }
+    destroy() {
+        this.#coverSub?.unsubscribe();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layer/child-ref.mjs

@@ -0,0 +1,44 @@
+import { ElementRef } from "@angular/core";
+import { of } from "rxjs";
+import { StateChain } from "@ngutil/common";
+// TODO: disposing, disposed
+export class ChildRef extends ElementRef {
+    /**
+     * @internal
+     */
+    set zIndex(val) {
+        if (this._zIndex !== val) {
+            this._zIndex = val;
+            this.nativeElement.style.zIndex = String(val);
+        }
+    }
+    get zIndex() {
+        return this._zIndex;
+    }
+    constructor(nativeElement) {
+        super(nativeElement);
+        this.state = new StateChain({
+            showing: {},
+            shown: {},
+            disposing: { cancellable: false },
+            disposed: { cancellable: false, order: "sequential" }
+        });
+        this._zIndex = -1;
+        this.state.on("disposed", () => this.destroy());
+        // this.state.current$.subscribe(state => {
+        //     console.log(this, state)
+        // })
+    }
+    dispose() {
+        if (this.state == null) {
+            return of(null);
+        }
+        return this.state.run(["disposing", "disposed"]);
+    }
+    destroy() {
+        this.nativeElement.parentElement?.removeChild(this.nativeElement);
+        this.state.destroy();
+        delete this.state;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layer/container-ref.mjs

@@ -0,0 +1,37 @@
+import { Injector } from "@angular/core";
+import { ChildRef } from "./child-ref";
+export class ContainerRef extends ChildRef {
+    constructor(options) {
+        super(createElement(options));
+        this.options = options;
+        this.injectorName = "ContainerRef";
+        const providers = options.providers || [];
+        this.injector = Injector.create({
+            providers: [...this.getProviders(), ...providers],
+            parent: options.injector,
+            name: this.injectorName
+        });
+        this.state.on("disposed", () => {
+            delete this.options;
+            delete this.injector;
+        });
+    }
+    getProviders() {
+        return [
+            { provide: ChildRef, useValue: this },
+            { provide: ContainerRef, useValue: this }
+        ];
+    }
+}
+function createElement(options) {
+    const div = document.createElement("div");
+    div.style.position = "absolute";
+    div.style.top = "0";
+    div.style.left = "0";
+    div.style.width = "max-content";
+    if (options.classes) {
+        div.classList.add(...options.classes);
+    }
+    return div;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layer/index.mjs

@@ -0,0 +1,5 @@
+export * from "./backdrop-ref";
+export * from "./child-ref";
+export * from "./layer.service";
+export * from "./portal-ref";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9mbG9hdGluZy9zcmMvbGF5ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsY0FBYyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYmFja2Ryb3AtcmVmXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NoaWxkLXJlZlwiXG5leHBvcnQgKiBmcm9tIFwiLi9sYXllci5zZXJ2aWNlXCJcbmV4cG9ydCAqIGZyb20gXCIuL3BvcnRhbC1yZWZcIlxuIl19