@webiny/app-admin 6.6.0-alpha.0 → 6.6.0-alpha.10

package/presentation/listPresenter/QueryMatcher.test.js

@@ -0,0 +1,345 @@
+import { describe, expect, it } from "vitest";
+import { QueryMatcher } from "./QueryMatcher.js";
+const row = (id, savedOn, folderId = "root")=>({
+        id,
+        folderId,
+        savedOn
+    });
+const createMatcher = (config = {})=>new QueryMatcher({
+        keyField: "id",
+        localFilters: {
+            folderId: (item, value)=>item.folderId === value
+        },
+        ...config
+    });
+const ids = (rows)=>rows.map((r)=>r.id);
+describe("QueryMatcher.select", ()=>{
+    it("should only filter before the first query", ()=>{
+        const matcher = createMatcher();
+        expect(ids(matcher.select([
+            row("b", "2"),
+            row("a", "1")
+        ]))).toEqual([
+            "b",
+            "a"
+        ]);
+    });
+    it("should sort by the applied sort, regardless of cache order", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "DESC"
+            }
+        }, [
+            "c",
+            "b",
+            "a"
+        ]);
+        const cached = [
+            row("a", "1"),
+            row("c", "3"),
+            row("b", "2")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "c",
+            "b",
+            "a"
+        ]);
+    });
+    it("should apply local filters", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            filters: {
+                folderId: "root"
+            },
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ]);
+        const cached = [
+            row("a", "1"),
+            row("x", "0", "other"),
+            row("b", "2")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b"
+        ]);
+    });
+    it("should cut off items that sort past the last loaded item while more are available", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ], true);
+        const cached = [
+            row("z", "9"),
+            row("a", "1"),
+            row("b", "2")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b"
+        ]);
+    });
+    it("should include items past the last loaded item when nothing more is available", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ], false);
+        const cached = [
+            row("z", "9"),
+            row("a", "1"),
+            row("b", "2")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b",
+            "z"
+        ]);
+    });
+    it("should extend the loaded window on appendResultKeys", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a"
+        ], true);
+        matcher.appendResultKeys([
+            "b"
+        ], true);
+        const cached = [
+            row("c", "3"),
+            row("b", "2"),
+            row("a", "1")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b"
+        ]);
+    });
+    it("should keep the server order for items with equal sort values", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "DESC"
+            }
+        }, [
+            "b",
+            "a",
+            "c"
+        ]);
+        const cached = [
+            row("a", "1"),
+            row("c", "1"),
+            row("b", "1")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "b",
+            "a",
+            "c"
+        ]);
+    });
+    it("should sort empty values last in ascending order", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ]);
+        const cached = [
+            row("n"),
+            row("b", "2"),
+            row("u"),
+            row("a", "1")
+        ];
+        cached[0].savedOn = null;
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b",
+            "n",
+            "u"
+        ]);
+    });
+    it("should sort empty values first in descending order", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "DESC"
+            }
+        }, [
+            "b",
+            "a"
+        ]);
+        expect(ids(matcher.select([
+            row("a", "1"),
+            row("e"),
+            row("b", "2")
+        ]))).toEqual([
+            "e",
+            "b",
+            "a"
+        ]);
+    });
+    it("should sort an empty string as a regular string", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ]);
+        expect(ids(matcher.select([
+            row("b", "1"),
+            row("u"),
+            row("a", "")
+        ]))).toEqual([
+            "a",
+            "b",
+            "u"
+        ]);
+    });
+    it("should keep the server order while searching", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            search: "hello",
+            sort: {
+                field: "savedOn",
+                direction: "ASC"
+            }
+        }, [
+            "c",
+            "a",
+            "b"
+        ]);
+        const cached = [
+            row("a", "1"),
+            row("b", "2"),
+            row("c", "3"),
+            row("x", "0")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "c",
+            "a",
+            "b"
+        ]);
+    });
+    it("should read nested sort fields by path", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "values.title",
+                direction: "ASC"
+            }
+        }, [
+            "a",
+            "b"
+        ]);
+        const cached = [
+            {
+                id: "b",
+                folderId: "root",
+                values: {
+                    title: "Beta"
+                }
+            },
+            {
+                id: "a",
+                folderId: "root",
+                values: {
+                    title: "Alpha"
+                }
+            }
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "a",
+            "b"
+        ]);
+    });
+    it("should use a custom sort value getter", ()=>{
+        const matcher = createMatcher({
+            getSortValue: (item, field)=>"title" === field ? item.values?.title : void 0
+        });
+        matcher.updateFromQuery({
+            sort: {
+                field: "title",
+                direction: "DESC"
+            }
+        }, [
+            "a",
+            "b"
+        ]);
+        const cached = [
+            {
+                id: "a",
+                folderId: "root",
+                values: {
+                    title: "Alpha"
+                }
+            },
+            {
+                id: "b",
+                folderId: "root",
+                values: {
+                    title: "Beta"
+                }
+            }
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "b",
+            "a"
+        ]);
+    });
+    it("should put items the server did not return after the server's items among equal values", ()=>{
+        const matcher = createMatcher();
+        matcher.updateFromQuery({
+            sort: {
+                field: "savedOn",
+                direction: "DESC"
+            }
+        }, [
+            "b",
+            "a"
+        ], true);
+        const cached = [
+            row("x", "1"),
+            row("a", "1"),
+            row("y", "1"),
+            row("b", "1")
+        ];
+        expect(ids(matcher.select(cached))).toEqual([
+            "b",
+            "a"
+        ]);
+    });
+});
+
+//# sourceMappingURL=QueryMatcher.test.js.map

package/presentation/listPresenter/QueryMatcher.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation/listPresenter/QueryMatcher.test.js","sources":["../../../src/presentation/listPresenter/QueryMatcher.test.ts"],"sourcesContent":["import { describe, it, expect } from \"vitest\";\nimport { QueryMatcher } from \"./QueryMatcher.js\";\n\ninterface Row {\n    id: string;\n    folderId: string;\n    savedOn?: string;\n    values?: { title?: string };\n}\n\nconst row = (id: string, savedOn?: string, folderId = \"root\"): Row => ({ id, folderId, savedOn });\n\nconst createMatcher = (config: Partial<ConstructorParameters<typeof QueryMatcher<Row>>[0]> = {}) =>\n    new QueryMatcher<Row>({\n        keyField: \"id\",\n        localFilters: {\n            folderId: (item, value) => item.folderId === value\n        },\n        ...config\n    });\n\nconst ids = (rows: Row[]) => rows.map(r => r.id);\n\ndescribe(\"QueryMatcher.select\", () => {\n    it(\"should only filter before the first query\", () => {\n        const matcher = createMatcher();\n\n        expect(ids(matcher.select([row(\"b\", \"2\"), row(\"a\", \"1\")]))).toEqual([\"b\", \"a\"]);\n    });\n\n    it(\"should sort by the applied sort, regardless of cache order\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"DESC\" } }, [\"c\", \"b\", \"a\"]);\n\n        const cached = [row(\"a\", \"1\"), row(\"c\", \"3\"), row(\"b\", \"2\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"c\", \"b\", \"a\"]);\n    });\n\n    it(\"should apply local filters\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery(\n            { filters: { folderId: \"root\" }, sort: { field: \"savedOn\", direction: \"ASC\" } },\n            [\"a\", \"b\"]\n        );\n\n        const cached = [row(\"a\", \"1\"), row(\"x\", \"0\", \"other\"), row(\"b\", \"2\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\"]);\n    });\n\n    it(\"should cut off items that sort past the last loaded item while more are available\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"ASC\" } }, [\"a\", \"b\"], true);\n\n        // \"z\" was cached by another view and sorts after the loaded window.\n        const cached = [row(\"z\", \"9\"), row(\"a\", \"1\"), row(\"b\", \"2\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\"]);\n    });\n\n    it(\"should include items past the last loaded item when nothing more is available\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery(\n            { sort: { field: \"savedOn\", direction: \"ASC\" } },\n            [\"a\", \"b\"],\n            false\n        );\n\n        const cached = [row(\"z\", \"9\"), row(\"a\", \"1\"), row(\"b\", \"2\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\", \"z\"]);\n    });\n\n    it(\"should extend the loaded window on appendResultKeys\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"ASC\" } }, [\"a\"], true);\n        matcher.appendResultKeys([\"b\"], true);\n\n        const cached = [row(\"c\", \"3\"), row(\"b\", \"2\"), row(\"a\", \"1\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\"]);\n    });\n\n    it(\"should keep the server order for items with equal sort values\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"DESC\" } }, [\"b\", \"a\", \"c\"]);\n\n        const cached = [row(\"a\", \"1\"), row(\"c\", \"1\"), row(\"b\", \"1\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"b\", \"a\", \"c\"]);\n    });\n\n    // Empty values are ordered the same way as the DDB and SQL storage sort them.\n    it(\"should sort empty values last in ascending order\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"ASC\" } }, [\"a\", \"b\"]);\n\n        const cached = [row(\"n\"), row(\"b\", \"2\"), row(\"u\"), row(\"a\", \"1\")];\n        cached[0].savedOn = null as unknown as string;\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\", \"n\", \"u\"]);\n    });\n\n    it(\"should sort empty values first in descending order\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"DESC\" } }, [\"b\", \"a\"]);\n\n        expect(ids(matcher.select([row(\"a\", \"1\"), row(\"e\"), row(\"b\", \"2\")]))).toEqual([\n            \"e\",\n            \"b\",\n            \"a\"\n        ]);\n    });\n\n    it(\"should sort an empty string as a regular string\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"savedOn\", direction: \"ASC\" } }, [\"a\", \"b\"]);\n\n        expect(ids(matcher.select([row(\"b\", \"1\"), row(\"u\"), row(\"a\", \"\")]))).toEqual([\n            \"a\",\n            \"b\",\n            \"u\"\n        ]);\n    });\n\n    it(\"should keep the server order while searching\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ search: \"hello\", sort: { field: \"savedOn\", direction: \"ASC\" } }, [\n            \"c\",\n            \"a\",\n            \"b\"\n        ]);\n\n        const cached = [row(\"a\", \"1\"), row(\"b\", \"2\"), row(\"c\", \"3\"), row(\"x\", \"0\")];\n\n        expect(ids(matcher.select(cached))).toEqual([\"c\", \"a\", \"b\"]);\n    });\n\n    it(\"should read nested sort fields by path\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery({ sort: { field: \"values.title\", direction: \"ASC\" } }, [\"a\", \"b\"]);\n\n        const cached: Row[] = [\n            { id: \"b\", folderId: \"root\", values: { title: \"Beta\" } },\n            { id: \"a\", folderId: \"root\", values: { title: \"Alpha\" } }\n        ];\n\n        expect(ids(matcher.select(cached))).toEqual([\"a\", \"b\"]);\n    });\n\n    it(\"should use a custom sort value getter\", () => {\n        const matcher = createMatcher({\n            getSortValue: (item, field) => (field === \"title\" ? item.values?.title : undefined)\n        });\n        matcher.updateFromQuery({ sort: { field: \"title\", direction: \"DESC\" } }, [\"a\", \"b\"]);\n\n        const cached: Row[] = [\n            { id: \"a\", folderId: \"root\", values: { title: \"Alpha\" } },\n            { id: \"b\", folderId: \"root\", values: { title: \"Beta\" } }\n        ];\n\n        expect(ids(matcher.select(cached))).toEqual([\"b\", \"a\"]);\n    });\n\n    it(\"should put items the server did not return after the server's items among equal values\", () => {\n        const matcher = createMatcher();\n        matcher.updateFromQuery(\n            { sort: { field: \"savedOn\", direction: \"DESC\" } },\n            [\"b\", \"a\"],\n            true\n        );\n\n        // \"x\" and \"y\" were cached by another view and tie with the loaded items.\n        const cached = [row(\"x\", \"1\"), row(\"a\", \"1\"), row(\"y\", \"1\"), row(\"b\", \"1\")];\n\n        // Server items come first, in server order, and the tied leftovers are cut off\n        // together with everything else past the last loaded item.\n        expect(ids(matcher.select(cached))).toEqual([\"b\", \"a\"]);\n    });\n});\n"],"names":["row","id","savedOn","folderId","createMatcher","config","QueryMatcher","item","value","ids","rows","r","describe","it","matcher","expect","cached","field","undefined"],"mappings":"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"}

package/presentation/sortable/SortablePresenter.d.ts

@@ -0,0 +1,23 @@
+import { SortablePresenter as Abstraction } from "./abstractions.js";
+declare class SortablePresenterImpl implements Abstraction.Interface {
+    private draggingIndex;
+    private overIndex;
+    private closestEdge;
+    private cleanups;
+    private config;
+    constructor();
+    init(config: Abstraction.Config): void;
+    getItemProps(index: number): Abstraction.ItemProps;
+    dispose(): void;
+    private get type();
+    private isOwnDrag;
+    private getVisibleEdge;
+    private clearDropState;
+    private computeDestination;
+    private registerDropTarget;
+    private registerDraggable;
+}
+export declare const SortablePresenter: typeof SortablePresenterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISortablePresenter>;
+};
+export {};

package/presentation/sortable/SortablePresenter.js

@@ -0,0 +1,175 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { draggable, dropTargetForElements } from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import { attachClosestEdge, extractClosestEdge } from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+import { SortablePresenter } from "./abstractions.js";
+function toSortableEdge(edge) {
+    if ("top" === edge || "bottom" === edge) return edge;
+    return null;
+}
+function getIndex(data) {
+    const index = data["index"];
+    if ("number" == typeof index) return index;
+    return null;
+}
+function getType(data) {
+    const type = data["type"];
+    if ("string" == typeof type) return type;
+    return null;
+}
+class SortablePresenterImpl {
+    constructor(){
+        this.draggingIndex = null;
+        this.overIndex = null;
+        this.closestEdge = null;
+        this.cleanups = new Map();
+        this.config = null;
+        makeAutoObservable(this, {
+            cleanups: false,
+            config: false
+        });
+    }
+    init(config) {
+        this.config = config;
+    }
+    getItemProps(index) {
+        return {
+            ref: (element)=>{
+                this.registerDropTarget(index, element);
+            },
+            handleRef: (element)=>{
+                this.registerDraggable(index, element);
+            },
+            isDragging: this.draggingIndex === index,
+            isOver: this.overIndex === index && this.draggingIndex !== index,
+            closestEdge: this.getVisibleEdge(index)
+        };
+    }
+    dispose() {
+        for (const cleanup of this.cleanups.values())cleanup();
+        this.cleanups.clear();
+        this.draggingIndex = null;
+        this.overIndex = null;
+        this.closestEdge = null;
+    }
+    get type() {
+        return this.config.type;
+    }
+    isOwnDrag(data) {
+        return getType(data) === this.type;
+    }
+    getVisibleEdge(index) {
+        if (this.overIndex !== index || this.draggingIndex === index || null === this.draggingIndex) return null;
+        const edge = this.closestEdge;
+        if ("top" === edge && this.draggingIndex === index - 1) return null;
+        if ("bottom" === edge && this.draggingIndex === index + 1) return null;
+        return edge;
+    }
+    clearDropState() {
+        this.draggingIndex = null;
+        this.overIndex = null;
+        this.closestEdge = null;
+    }
+    computeDestination(fromIndex, toIndex, edge) {
+        let destinationIndex = toIndex;
+        if ("bottom" === edge) destinationIndex = fromIndex < toIndex ? toIndex : toIndex + 1;
+        else if ("top" === edge) destinationIndex = fromIndex > toIndex ? toIndex : toIndex - 1;
+        return destinationIndex;
+    }
+    registerDropTarget(index, element) {
+        const key = 2 * index;
+        const existing = this.cleanups.get(key);
+        if (existing) {
+            existing();
+            this.cleanups.delete(key);
+        }
+        if (!element) return;
+        const cleanup = dropTargetForElements({
+            element,
+            canDrop: ({ source })=>this.isOwnDrag(source.data) && getIndex(source.data) !== index,
+            getData: ({ input })=>attachClosestEdge({
+                    index,
+                    type: this.type
+                }, {
+                    element,
+                    input,
+                    allowedEdges: [
+                        "top",
+                        "bottom"
+                    ]
+                }),
+            onDragEnter: ({ self, source })=>{
+                if (!this.isOwnDrag(source.data)) return;
+                runInAction(()=>{
+                    this.overIndex = index;
+                    this.closestEdge = toSortableEdge(extractClosestEdge(self.data));
+                });
+            },
+            onDrag: ({ self, source })=>{
+                if (!this.isOwnDrag(source.data)) return;
+                runInAction(()=>{
+                    this.overIndex = index;
+                    this.closestEdge = toSortableEdge(extractClosestEdge(self.data));
+                });
+            },
+            onDragLeave: ({ source })=>{
+                if (!this.isOwnDrag(source.data)) return;
+                runInAction(()=>{
+                    if (this.overIndex === index) {
+                        this.overIndex = null;
+                        this.closestEdge = null;
+                    }
+                });
+            },
+            onDrop: ({ self, source })=>{
+                if (!this.isOwnDrag(source.data)) return;
+                const fromIndex = getIndex(source.data);
+                const toIndex = getIndex(self.data);
+                const edge = toSortableEdge(extractClosestEdge(self.data));
+                runInAction(()=>{
+                    this.clearDropState();
+                });
+                if (null === fromIndex || null === toIndex || !this.config) return;
+                const destinationIndex = this.computeDestination(fromIndex, toIndex, edge);
+                if (destinationIndex !== fromIndex) this.config.onReorder(fromIndex, destinationIndex);
+            }
+        });
+        this.cleanups.set(key, cleanup);
+    }
+    registerDraggable(index, element) {
+        const key = 2 * index + 1;
+        const existing = this.cleanups.get(key);
+        if (existing) {
+            existing();
+            this.cleanups.delete(key);
+        }
+        if (!element) return;
+        const container = element.closest("[data-sortable-item]");
+        if (!container) return;
+        const cleanup = draggable({
+            element: container,
+            dragHandle: element,
+            getInitialData: ()=>({
+                    index,
+                    type: this.type
+                }),
+            onDragStart: ()=>{
+                runInAction(()=>{
+                    this.draggingIndex = index;
+                });
+            },
+            onDrop: ()=>{
+                runInAction(()=>{
+                    this.clearDropState();
+                });
+            }
+        });
+        this.cleanups.set(key, cleanup);
+    }
+}
+const SortablePresenter_SortablePresenter = SortablePresenter.createImplementation({
+    implementation: SortablePresenterImpl,
+    dependencies: []
+});
+export { SortablePresenter_SortablePresenter as SortablePresenter };
+
+//# sourceMappingURL=SortablePresenter.js.map

package/presentation/sortable/SortablePresenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation/sortable/SortablePresenter.js","sources":["../../../src/presentation/sortable/SortablePresenter.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport {\n    draggable,\n    dropTargetForElements\n} from \"@atlaskit/pragmatic-drag-and-drop/element/adapter\";\nimport {\n    attachClosestEdge,\n    extractClosestEdge\n} from \"@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge\";\nimport { SortablePresenter as Abstraction } from \"./abstractions.js\";\n\nfunction toSortableEdge(edge: string | null): Abstraction.Edge | null {\n    if (edge === \"top\" || edge === \"bottom\") {\n        return edge;\n    }\n    return null;\n}\n\nfunction getIndex(data: Record<string | symbol, unknown>): number | null {\n    const index = data[\"index\"];\n    if (typeof index === \"number\") {\n        return index;\n    }\n    return null;\n}\n\nfunction getType(data: Record<string | symbol, unknown>): string | null {\n    const type = data[\"type\"];\n    if (typeof type === \"string\") {\n        return type;\n    }\n    return null;\n}\n\nclass SortablePresenterImpl implements Abstraction.Interface {\n    private draggingIndex: number | null = null;\n    private overIndex: number | null = null;\n    private closestEdge: Abstraction.Edge | null = null;\n    private cleanups = new Map<number, () => void>();\n    private config: Abstraction.Config | null = null;\n\n    constructor() {\n        makeAutoObservable<SortablePresenterImpl, \"cleanups\" | \"config\">(this, {\n            cleanups: false,\n            config: false\n        });\n    }\n\n    init(config: Abstraction.Config): void {\n        this.config = config;\n    }\n\n    getItemProps(index: number): Abstraction.ItemProps {\n        return {\n            ref: (element: HTMLElement | null) => {\n                this.registerDropTarget(index, element);\n            },\n            handleRef: (element: HTMLElement | null) => {\n                this.registerDraggable(index, element);\n            },\n            isDragging: this.draggingIndex === index,\n            isOver: this.overIndex === index && this.draggingIndex !== index,\n            closestEdge: this.getVisibleEdge(index)\n        };\n    }\n\n    dispose(): void {\n        for (const cleanup of this.cleanups.values()) {\n            cleanup();\n        }\n        this.cleanups.clear();\n        this.draggingIndex = null;\n        this.overIndex = null;\n        this.closestEdge = null;\n    }\n\n    private get type(): string {\n        return this.config!.type;\n    }\n\n    private isOwnDrag(data: Record<string | symbol, unknown>): boolean {\n        return getType(data) === this.type;\n    }\n\n    private getVisibleEdge(index: number): Abstraction.Edge | null {\n        if (\n            this.overIndex !== index ||\n            this.draggingIndex === index ||\n            this.draggingIndex === null\n        ) {\n            return null;\n        }\n        const edge = this.closestEdge;\n        if (edge === \"top\" && this.draggingIndex === index - 1) {\n            return null;\n        }\n        if (edge === \"bottom\" && this.draggingIndex === index + 1) {\n            return null;\n        }\n        return edge;\n    }\n\n    private clearDropState(): void {\n        this.draggingIndex = null;\n        this.overIndex = null;\n        this.closestEdge = null;\n    }\n\n    private computeDestination(\n        fromIndex: number,\n        toIndex: number,\n        edge: Abstraction.Edge | null\n    ): number {\n        let destinationIndex = toIndex;\n        if (edge === \"bottom\") {\n            destinationIndex = fromIndex < toIndex ? toIndex : toIndex + 1;\n        } else if (edge === \"top\") {\n            destinationIndex = fromIndex > toIndex ? toIndex : toIndex - 1;\n        }\n        return destinationIndex;\n    }\n\n    private registerDropTarget(index: number, element: HTMLElement | null): void {\n        const key = index * 2;\n        const existing = this.cleanups.get(key);\n        if (existing) {\n            existing();\n            this.cleanups.delete(key);\n        }\n\n        if (!element) {\n            return;\n        }\n\n        const cleanup = dropTargetForElements({\n            element,\n            canDrop: ({ source }) => {\n                return this.isOwnDrag(source.data) && getIndex(source.data) !== index;\n            },\n            getData: ({ input }) => {\n                return attachClosestEdge(\n                    { index, type: this.type },\n                    { element, input, allowedEdges: [\"top\", \"bottom\"] }\n                );\n            },\n            onDragEnter: ({ self, source }) => {\n                if (!this.isOwnDrag(source.data)) {\n                    return;\n                }\n                runInAction(() => {\n                    this.overIndex = index;\n                    this.closestEdge = toSortableEdge(extractClosestEdge(self.data));\n                });\n            },\n            onDrag: ({ self, source }) => {\n                if (!this.isOwnDrag(source.data)) {\n                    return;\n                }\n                runInAction(() => {\n                    this.overIndex = index;\n                    this.closestEdge = toSortableEdge(extractClosestEdge(self.data));\n                });\n            },\n            onDragLeave: ({ source }) => {\n                if (!this.isOwnDrag(source.data)) {\n                    return;\n                }\n                runInAction(() => {\n                    if (this.overIndex === index) {\n                        this.overIndex = null;\n                        this.closestEdge = null;\n                    }\n                });\n            },\n            onDrop: ({ self, source }) => {\n                if (!this.isOwnDrag(source.data)) {\n                    return;\n                }\n\n                const fromIndex = getIndex(source.data);\n                const toIndex = getIndex(self.data);\n                const edge = toSortableEdge(extractClosestEdge(self.data));\n\n                runInAction(() => {\n                    this.clearDropState();\n                });\n\n                if (fromIndex === null || toIndex === null || !this.config) {\n                    return;\n                }\n\n                const destinationIndex = this.computeDestination(fromIndex, toIndex, edge);\n                if (destinationIndex !== fromIndex) {\n                    this.config.onReorder(fromIndex, destinationIndex);\n                }\n            }\n        });\n\n        this.cleanups.set(key, cleanup);\n    }\n\n    private registerDraggable(index: number, element: HTMLElement | null): void {\n        const key = index * 2 + 1;\n        const existing = this.cleanups.get(key);\n        if (existing) {\n            existing();\n            this.cleanups.delete(key);\n        }\n\n        if (!element) {\n            return;\n        }\n\n        const container = element.closest(\"[data-sortable-item]\") as HTMLElement | null;\n        if (!container) {\n            return;\n        }\n\n        const cleanup = draggable({\n            element: container,\n            dragHandle: element,\n            getInitialData: () => ({ index, type: this.type }),\n            onDragStart: () => {\n                runInAction(() => {\n                    this.draggingIndex = index;\n                });\n            },\n            onDrop: () => {\n                runInAction(() => {\n                    this.clearDropState();\n                });\n            }\n        });\n\n        this.cleanups.set(key, cleanup);\n    }\n}\n\nexport const SortablePresenter = Abstraction.createImplementation({\n    implementation: SortablePresenterImpl,\n    dependencies: []\n});\n"],"names":["toSortableEdge","edge","getIndex","data","index","getType","type","SortablePresenterImpl","Map","makeAutoObservable","config","element","cleanup","fromIndex","toIndex","destinationIndex","key","existing","dropTargetForElements","source","input","attachClosestEdge","self","runInAction","extractClosestEdge","container","draggable","SortablePresenter","Abstraction"],"mappings":"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"}

package/presentation/sortable/abstractions.d.ts

@@ -0,0 +1,24 @@
+export type SortableEdge = "top" | "bottom";
+export interface ISortableItemProps {
+    ref: (element: HTMLElement | null) => void;
+    handleRef: (element: HTMLElement | null) => void;
+    isDragging: boolean;
+    isOver: boolean;
+    closestEdge: SortableEdge | null;
+}
+export interface ISortablePresenterConfig {
+    type: string;
+    onReorder: (fromIndex: number, toIndex: number) => void;
+}
+export interface ISortablePresenter {
+    init(config: ISortablePresenterConfig): void;
+    getItemProps(index: number): ISortableItemProps;
+    dispose(): void;
+}
+export declare const SortablePresenter: import("@webiny/di").Abstraction<ISortablePresenter>;
+export declare namespace SortablePresenter {
+    type Interface = ISortablePresenter;
+    type Config = ISortablePresenterConfig;
+    type ItemProps = ISortableItemProps;
+    type Edge = SortableEdge;
+}

package/presentation/sortable/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const SortablePresenter = createAbstraction("SortablePresenter");
+export { SortablePresenter };
+
+//# sourceMappingURL=abstractions.js.map

package/presentation/sortable/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation/sortable/abstractions.js","sources":["../../../src/presentation/sortable/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport type SortableEdge = \"top\" | \"bottom\";\n\nexport interface ISortableItemProps {\n    ref: (element: HTMLElement | null) => void;\n    handleRef: (element: HTMLElement | null) => void;\n    isDragging: boolean;\n    isOver: boolean;\n    closestEdge: SortableEdge | null;\n}\n\nexport interface ISortablePresenterConfig {\n    type: string;\n    onReorder: (fromIndex: number, toIndex: number) => void;\n}\n\nexport interface ISortablePresenter {\n    init(config: ISortablePresenterConfig): void;\n    getItemProps(index: number): ISortableItemProps;\n    dispose(): void;\n}\n\nexport const SortablePresenter = createAbstraction<ISortablePresenter>(\"SortablePresenter\");\n\nexport namespace SortablePresenter {\n    export type Interface = ISortablePresenter;\n    export type Config = ISortablePresenterConfig;\n    export type ItemProps = ISortableItemProps;\n    export type Edge = SortableEdge;\n}\n"],"names":["SortablePresenter","createAbstraction"],"mappings":";AAuBO,MAAMA,oBAAoBC,kBAAsC"}

package/presentation/sortable/feature.d.ts

@@ -0,0 +1 @@
+export declare const SortableFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/presentation/sortable/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/admin";
+import { SortablePresenter } from "./SortablePresenter.js";
+const SortableFeature = createFeature({
+    name: "Sortable",
+    register (container) {
+        container.register(SortablePresenter);
+    }
+});
+export { SortableFeature };
+
+//# sourceMappingURL=feature.js.map

package/presentation/sortable/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation/sortable/feature.js","sources":["../../../src/presentation/sortable/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { SortablePresenter } from \"./SortablePresenter.js\";\n\nexport const SortableFeature = createFeature({\n    name: \"Sortable\",\n    register(container) {\n        container.register(SortablePresenter);\n    }\n});\n"],"names":["SortableFeature","createFeature","container","SortablePresenter"],"mappings":";;AAGO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/presentation/sortable/index.d.ts

@@ -0,0 +1,2 @@
+export { SortablePresenter, type ISortablePresenter, type ISortablePresenterConfig, type ISortableItemProps, type SortableEdge } from "./abstractions.js";
+export { SortableFeature } from "./feature.js";

package/presentation/sortable/index.js

@@ -0,0 +1,2 @@
+export { SortablePresenter } from "./abstractions.js";
+export { SortableFeature } from "./feature.js";