@nemigo/svelte 2.9.0 → 2.10.1

package/dist/heap.d.ts

@@ -0,0 +1,26 @@
+import { Emitter } from "@nemigo/helpers/emitter";
+import { SvelteMap } from "svelte/reactivity";
+import type { ISvelteState } from "./index.svelte.js";
+export interface HeapRecord {
+    id: string;
+}
+export interface HeapItem<R extends HeapRecord> {
+    record: ISvelteState<R>;
+}
+export declare abstract class SvelteHeap<R extends HeapRecord, Item extends HeapItem<R> = HeapItem<R>> extends Emitter<{
+    "before-create": Item;
+    "after-create": Item;
+    "before-update": Item;
+    "after-update": Item;
+    "before-delete": Item;
+    "after-delete": Item;
+}> {
+    map: SvelteMap<string, Item>;
+    abstract toHeapItem(record: R): Item;
+    hooks: {
+        create: (record: R) => void;
+        update: (record: R, mods: any) => void;
+        delete: (id: string) => void;
+    };
+    __build(records: R[]): void;
+}

package/dist/heap.js

@@ -0,0 +1,37 @@
+import { isDataEqual } from "@nemigo/helpers";
+import { Emitter } from "@nemigo/helpers/emitter";
+import { SvelteMap } from "svelte/reactivity";
+export class SvelteHeap extends Emitter {
+    map = new SvelteMap();
+    hooks = {
+        create: (record) => {
+            const item = this.toHeapItem(record);
+            this.dispatch("before-create", item);
+            this.map.set(record.id, item);
+            this.dispatch("after-create", item);
+        },
+        update: (record, mods) => {
+            const item = this.map.get(record.id);
+            if (!item)
+                return;
+            const result = { ...item.record.signal, ...mods };
+            if (isDataEqual(record, result))
+                return;
+            this.dispatch("before-update", item);
+            item.record.signal = result;
+            this.dispatch("after-update", item);
+        },
+        delete: (id) => {
+            const item = this.map.get(id);
+            if (!item)
+                return;
+            this.dispatch("before-update", item);
+            this.map.delete(id);
+            this.dispatch("after-update", item);
+        },
+    };
+    __build(records) {
+        for (const r of records)
+            this.map.set(r.id, this.toHeapItem(r));
+    }
+}

package/dist/list.d.ts

@@ -0,0 +1,33 @@
+import { Emitter } from "@nemigo/helpers/emitter";
+import type { ISvelteState } from "./index.svelte.js";
+export interface ListRecord {
+    id: string;
+}
+export interface ListItem<R extends ListRecord> {
+    record: ISvelteState<R>;
+}
+export declare abstract class SvelteList<R extends ListRecord, Item extends ListItem<R> = ListItem<R>> extends Emitter<{
+    "before-create": Item;
+    "after-create": Item;
+    "before-update": Item;
+    "after-update": Item;
+    "before-delete": Item;
+    "after-delete": Item;
+}> {
+    items: ISvelteState<Item[]>;
+    map: Map<string, Item>;
+    size: ISvelteState<number>;
+    abstract toListItem(record: R): Item;
+    abstract sort(a: Item, b: Item): number;
+    hooks: {
+        create: (record: R) => void;
+        update: (record: R, mods: any) => void;
+        delete: (id: string) => void;
+    };
+    __sort(): void;
+    __push(item: Item): void;
+    __splice(idx: number): void;
+    __delete(item: Item): void;
+    clear(): void;
+    __build(records: R[]): void;
+}

package/dist/list.js

@@ -0,0 +1,70 @@
+import { isDataEqual } from "@nemigo/helpers";
+import { Emitter } from "@nemigo/helpers/emitter";
+import { createSvelteRawState } from "./index.svelte.js";
+export class SvelteList extends Emitter {
+    items = createSvelteRawState([]);
+    map = new Map();
+    size = createSvelteRawState(0);
+    hooks = {
+        create: (record) => {
+            const item = this.toListItem(record);
+            this.dispatch("before-create", item);
+            this.map.set(record.id, item);
+            this.__push(item);
+            this.size.signal = this.map.size;
+            this.dispatch("after-create", item);
+        },
+        update: (record, mods) => {
+            const item = this.map.get(record.id);
+            if (!item)
+                return;
+            const result = { ...item.record.signal, ...mods };
+            if (isDataEqual(record, result))
+                return;
+            this.dispatch("before-update", item);
+            item.record.signal = result;
+            this.__sort();
+            this.dispatch("after-update", item);
+        },
+        delete: (id) => {
+            const item = this.map.get(id);
+            if (!item)
+                return;
+            this.dispatch("before-delete", item);
+            this.map.delete(id);
+            this.__delete(item);
+            this.size.signal = this.map.size;
+            this.dispatch("after-delete", item);
+        },
+    };
+    __sort() {
+        this.items.signal = this.items.signal.toSorted((a, b) => this.sort(a, b));
+    }
+    __push(item) {
+        this.items.signal.push(item);
+        this.__sort();
+    }
+    __splice(idx) {
+        this.items.signal.splice(idx, 1);
+        this.items.signal = this.items.signal.slice();
+    }
+    __delete(item) {
+        const idx = this.items.signal.indexOf(item);
+        if (idx !== -1)
+            this.__splice(idx);
+    }
+    clear() {
+        this.items.signal = [];
+        this.map.clear();
+        this.size.signal = 0;
+    }
+    __build(records) {
+        for (const r of records) {
+            const item = this.toListItem(r);
+            this.map.set(r.id, item);
+            this.items.signal.push(item);
+        }
+        this.__sort();
+        this.size.signal = this.map.size;
+    }
+}

package/dist/record.d.ts

@@ -0,0 +1,22 @@
+import { Emitter } from "@nemigo/helpers/emitter";
+import type { ISvelteState } from "./index.svelte.js";
+export declare abstract class SvelteRecord<R extends {
+    id: string;
+}> extends Emitter<{
+    "before-create": R;
+    "after-create": R;
+    "before-update": R;
+    "after-update": R;
+    "before-delete": R;
+    "after-delete": R;
+}> {
+    id: string;
+    record: ISvelteState<R | null>;
+    constructor(id: string);
+    hooks: {
+        create: (record: R) => void;
+        update: (record: R, mods: any) => void;
+        delete: (id: string) => void;
+    };
+    __build(record: R | null): void;
+}

package/dist/record.js

@@ -0,0 +1,42 @@
+import { isDataEqual } from "@nemigo/helpers";
+import { Emitter } from "@nemigo/helpers/emitter";
+import { createSvelteRawState } from "./index.svelte.js";
+export class SvelteRecord extends Emitter {
+    id;
+    record = createSvelteRawState(null);
+    constructor(id) {
+        super();
+        this.id = id;
+    }
+    hooks = {
+        create: (record) => {
+            if (record.id !== this.id)
+                return;
+            this.dispatch("before-create", record);
+            this.record.signal = record;
+            this.dispatch("after-create", record);
+        },
+        update: (record, mods) => {
+            const current = this.record.signal;
+            if (!current || current.id !== record.id)
+                return;
+            const result = { ...current, ...mods };
+            if (isDataEqual(current, result))
+                return;
+            this.dispatch("before-update", result);
+            this.record.signal = result;
+            this.dispatch("after-update", result);
+        },
+        delete: (id) => {
+            const current = this.record.signal;
+            if (!current || current.id !== id)
+                return;
+            this.dispatch("before-delete", current);
+            this.record.signal = null;
+            this.dispatch("after-delete", current);
+        },
+    };
+    __build(record) {
+        this.record.signal = record;
+    }
+}

package/dist/tree.d.ts

@@ -0,0 +1,51 @@
+import { Emitter } from "@nemigo/helpers/emitter";
+import type { ISvelteState } from "./index.svelte.js";
+export interface TreeRecord {
+    id: string;
+    parent_id: string | null;
+}
+export interface TreeItem<R extends TreeRecord, Item extends TreeItem<R, any>> {
+    child: ISvelteState<Item[]>;
+    record: ISvelteState<R>;
+}
+export interface BeforeParentUpdateTreeEvent<R extends TreeRecord, Item extends TreeItem<R, any>> {
+    prev: string | null;
+    item: Item;
+    preview: R;
+    mods: any;
+}
+export interface AfterParentUpdateTreeEvent<Item extends TreeItem<TreeRecord, any>> {
+    prev: string | null;
+    item: Item;
+    mods: any;
+}
+export declare abstract class SvelteTree<R extends TreeRecord, Item extends TreeItem<R, any> = TreeItem<R, any>> extends Emitter<{
+    "before-create": Item;
+    "after-create": Item;
+    "before-update": Item;
+    "after-update": Item;
+    "before-parent-update": BeforeParentUpdateTreeEvent<R, Item>;
+    "after-parent-update": AfterParentUpdateTreeEvent<Item>;
+    "after-delete-child": Item;
+    "before-delete-child": Item;
+    "before-delete": Item;
+    "after-delete": Item;
+}> {
+    items: ISvelteState<Item[]>;
+    map: Map<string, Item>;
+    size: ISvelteState<number>;
+    abstract toTreeItem(record: R): Item;
+    abstract sort(a: Item, b: Item): number;
+    hooks: {
+        create: (record: R) => void;
+        update: (record: R, mods: any) => void;
+        delete: (id: string) => void;
+    };
+    __sort(items: ISvelteState<Item[]>): void;
+    __push(items: ISvelteState<Item[]>, item: Item): void;
+    __splice(items: ISvelteState<Item[]>, idx: number): void;
+    __delete(items: ISvelteState<Item[]>, item: Item): void;
+    __parent(item: Item, call: (items: ISvelteState<Item[]>) => void): void;
+    clear(): void;
+    __build(records: R[]): void;
+}

package/dist/tree.js

@@ -0,0 +1,132 @@
+import { isDataEqual } from "@nemigo/helpers";
+import { Emitter } from "@nemigo/helpers/emitter";
+import { createSvelteRawState } from "./index.svelte.js";
+export class SvelteTree extends Emitter {
+    items = createSvelteRawState([]);
+    map = new Map();
+    size = createSvelteRawState(0);
+    hooks = {
+        create: (record) => {
+            const item = this.toTreeItem(record);
+            this.dispatch("before-create", item);
+            this.map.set(record.id, item);
+            this.__parent(item, (items) => {
+                this.__push(items, item);
+            });
+            this.size.signal = this.map.size;
+            this.dispatch("after-create", item);
+        },
+        update: (record, mods) => {
+            const item = this.map.get(record.id);
+            if (!item)
+                return;
+            const preview = { ...item.record.signal, ...mods };
+            if (isDataEqual(record, preview))
+                return;
+            const prev_parent_id = record.parent_id;
+            const mod_parent_id = mods.parent_id;
+            const isParentChange = mod_parent_id !== undefined && mod_parent_id !== prev_parent_id;
+            if (isParentChange) {
+                this.dispatch("before-parent-update", {
+                    prev: prev_parent_id,
+                    item,
+                    preview,
+                    mods,
+                });
+                this.__parent(item, (items) => {
+                    this.__delete(items, item);
+                });
+                item.record.signal = preview;
+                this.__parent(item, (items) => {
+                    this.__push(items, item);
+                });
+                this.dispatch("after-parent-update", {
+                    prev: prev_parent_id,
+                    item,
+                    mods,
+                });
+            }
+            else {
+                this.dispatch("before-update", item);
+                item.record.signal = preview;
+                this.__parent(item, (items) => {
+                    this.__sort(items);
+                });
+                this.dispatch("after-update", item);
+            }
+            this.size.signal = this.map.size;
+        },
+        delete: (id) => {
+            const item = this.map.get(id);
+            if (!item)
+                return;
+            this.dispatch("before-delete", item);
+            const delete_child = (it) => {
+                this.dispatch("before-delete-child", it);
+                for (const c of it.child.signal)
+                    delete_child(c);
+                this.map.delete(it.record.signal.id);
+                this.dispatch("after-delete-child", it);
+            };
+            delete_child(item);
+            this.__parent(item, (items) => {
+                this.__delete(items, item);
+            });
+            this.size.signal = this.map.size;
+            this.dispatch("after-delete", item);
+        },
+    };
+    __sort(items) {
+        items.signal = items.signal.toSorted((a, b) => this.sort(a, b)); // Триггерем эффекты
+    }
+    __push(items, item) {
+        items.signal.push(item);
+        this.__sort(items); // Триггерем эффекты
+    }
+    __splice(items, idx) {
+        items.signal.splice(idx, 1);
+        items.signal = items.signal.slice(); // Триггерем эффекты
+    }
+    __delete(items, item) {
+        const idx = items.signal.indexOf(item);
+        if (idx !== -1)
+            this.__splice(items, idx);
+    }
+    __parent(item, call) {
+        const parent_id = item.record.signal.parent_id;
+        if (parent_id) {
+            const parent = this.map.get(parent_id);
+            if (parent)
+                call(parent.child);
+        }
+        else {
+            call(this.items);
+        }
+    }
+    clear() {
+        this.items.signal = [];
+        this.map.clear();
+        this.size.signal = 0;
+    }
+    __build(records) {
+        // Первый проход: создаём все элементы и строим Map
+        for (const r of records)
+            this.map.set(r.id, this.toTreeItem(r));
+        // Второй проход: строим дерево
+        for (const r of records) {
+            const item = this.map.get(r.id);
+            const parent_id = r.parent_id;
+            if (parent_id)
+                this.map.get(parent_id)?.child.signal.push(item);
+            else
+                this.items.signal.push(item);
+        }
+        // Третий проход: всё сортируем
+        for (const r of records) {
+            const item = this.map.get(r.id);
+            this.__sort(item.child);
+        }
+        this.__sort(this.items);
+        this.size.signal = this.map.size;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/svelte",
-	"version": "2.9.0",
+	"version": "2.10.1",
 	"private": false,
 	"license": "MPL-2.0",
 	"author": {
@@ -26,21 +26,37 @@
 			"types": "./dist/kit/navigation.d.ts",
 			"svelte": "./dist/kit/navigation.js"
 		},
+		"./heap": {
+			"types": "./dist/heap.d.ts",
+			"svelte": "./dist/heap.js"
+		},
+		"./list": {
+			"types": "./dist/list.d.ts",
+			"svelte": "./dist/list.js"
+		},
 		"./loader": {
 			"types": "./dist/loader.d.ts",
 			"svelte": "./dist/loader.js"
 		},
+		"./record": {
+			"types": "./dist/record.d.ts",
+			"svelte": "./dist/record.js"
+		},
 		"./transitions": {
 			"types": "./dist/transitions.d.ts",
 			"default": "./dist/transitions.js"
 		},
+		"./tree": {
+			"types": "./dist/tree.d.ts",
+			"default": "./dist/tree.js"
+		},
 		"./types": {
 			"types": "./dist/types.d.ts",
 			"default": "./dist/types.js"
 		}
 	},
 	"peerDependencies": {
-		"@nemigo/helpers": ">=2.7.0",
+		"@nemigo/helpers": ">=2.10.0",
 		"@sveltejs/kit": ">=2.49.0",
 		"svelte": ">=5.46.0"
 	},