@nemigo/svelte 2.10.1 → 2.10.3

package/dist/tree.d.ts

@@ -34,8 +34,14 @@ export declare abstract class SvelteTree<R extends TreeRecord, Item extends Tree
     items: ISvelteState<Item[]>;
     map: Map<string, Item>;
     size: ISvelteState<number>;
+    root_parent_id: string | null;
+    constructor(root_parent_id?: string | null);
     abstract toTreeItem(record: R): Item;
     abstract sort(a: Item, b: Item): number;
+    /** true, если запись относится к нашему поддереву (корень или потомок) */
+    __inScope(record: R): boolean;
+    /** является ли этот parent_id "корнем" нашего поддерева */
+    __isRootParent(parent_id: string | null): boolean;
     hooks: {
         create: (record: R) => void;
         update: (record: R, mods: any) => void;

package/dist/tree.js

@@ -5,8 +5,27 @@ export class SvelteTree extends Emitter {
     items = createSvelteRawState([]);
     map = new Map();
     size = createSvelteRawState(0);
+    root_parent_id;
+    constructor(root_parent_id = null) {
+        super();
+        this.root_parent_id = root_parent_id;
+    }
+    /** true, если запись относится к нашему поддереву (корень или потомок) */
+    __inScope(record) {
+        // корневой уровень нашего поддерева
+        if (record.parent_id === this.root_parent_id)
+            return true;
+        // потомок — значит его родитель уже в map
+        return record.parent_id !== null && this.map.has(record.parent_id);
+    }
+    /** является ли этот parent_id "корнем" нашего поддерева */
+    __isRootParent(parent_id) {
+        return parent_id === this.root_parent_id;
+    }
     hooks = {
         create: (record) => {
+            if (!this.__inScope(record))
+                return;
             const item = this.toTreeItem(record);
             this.dispatch("before-create", item);
             this.map.set(record.id, item);
@@ -18,40 +37,33 @@ export class SvelteTree extends Emitter {
         },
         update: (record, mods) => {
             const item = this.map.get(record.id);
-            if (!item)
+            const current = item?.record.signal;
+            const preview = { ...(current ?? record), ...mods };
+            if (!item) {
+                if (this.__inScope(preview))
+                    this.hooks.create(preview);
+                return;
+            }
+            const prev_parent_id = current.parent_id;
+            const next_parent_id = preview.parent_id;
+            const isParentChange = prev_parent_id !== next_parent_id;
+            if (isParentChange && !this.__inScope(preview)) {
+                this.hooks.delete(record.id);
                 return;
-            const preview = { ...item.record.signal, ...mods };
-            if (isDataEqual(record, preview))
+            }
+            if (!isParentChange && isDataEqual(current, 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);
-                });
+                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,
-                });
+                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.__parent(item, (items) => this.__sort(items));
                 this.dispatch("after-update", item);
             }
             this.size.signal = this.map.size;
@@ -77,15 +89,15 @@ export class SvelteTree extends Emitter {
         },
     };
     __sort(items) {
-        items.signal = items.signal.toSorted((a, b) => this.sort(a, b)); // Триггерем эффекты
+        items.signal = items.signal.toSorted((a, b) => this.sort(a, b));
     }
     __push(items, item) {
         items.signal.push(item);
-        this.__sort(items); // Триггерем эффекты
+        this.__sort(items);
     }
     __splice(items, idx) {
         items.signal.splice(idx, 1);
-        items.signal = items.signal.slice(); // Триггерем эффекты
+        items.signal = items.signal.slice();
     }
     __delete(items, item) {
         const idx = items.signal.indexOf(item);
@@ -94,14 +106,14 @@ export class SvelteTree extends Emitter {
     }
     __parent(item, call) {
         const parent_id = item.record.signal.parent_id;
-        if (parent_id) {
+        if (this.__isRootParent(parent_id)) {
+            call(this.items);
+        }
+        else if (parent_id) {
             const parent = this.map.get(parent_id);
             if (parent)
                 call(parent.child);
         }
-        else {
-            call(this.items);
-        }
     }
     clear() {
         this.items.signal = [];
@@ -109,20 +121,42 @@ export class SvelteTree extends Emitter {
         this.size.signal = 0;
     }
     __build(records) {
-        // Первый проход: создаём все элементы и строим Map
+        // 1. индексируем все записи, чтобы корректно определять принадлежность к поддереву
+        const byId = new Map();
         for (const r of records)
+            byId.set(r.id, r);
+        // определяем, входит ли запись в наше поддерево (поднимаемся до корня)
+        const inScope = (r) => {
+            let cur = r;
+            const seen = new Set();
+            while (cur) {
+                if (cur.parent_id === this.root_parent_id)
+                    return true;
+                if (cur.parent_id === null)
+                    return false;
+                if (seen.has(cur.id))
+                    return false; // защита от циклов
+                seen.add(cur.id);
+                cur = byId.get(cur.parent_id);
+            }
+            return false;
+        };
+        const scoped = records.filter(inScope);
+        // 2. создаём элементы
+        for (const r of scoped)
             this.map.set(r.id, this.toTreeItem(r));
-        // Второй проход: строим дерево
-        for (const r of records) {
+        // 3. строим дерево
+        for (const r of scoped) {
             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
+            if (this.__isRootParent(r.parent_id)) {
                 this.items.signal.push(item);
+            }
+            else if (r.parent_id) {
+                this.map.get(r.parent_id)?.child.signal.push(item);
+            }
         }
-        // Третий проход: всё сортируем
-        for (const r of records) {
+        // 4. сортируем
+        for (const r of scoped) {
             const item = this.map.get(r.id);
             this.__sort(item.child);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/svelte",
-	"version": "2.10.1",
+	"version": "2.10.3",
 	"private": false,
 	"license": "MPL-2.0",
 	"author": {