@libs-ui/services-grid-layout 0.2.357-19

package/esm2022/tree.service.mjs

@@ -0,0 +1,180 @@
+import { Injectable } from '@angular/core';
+import { uuid } from '@libs-ui/utils';
+import * as i0 from "@angular/core";
+/**
+ * Thao tác trên cây khối: tìm, thêm, xoá, dồn khít, chặn lồng cấp quá sâu.
+ *
+ * 🔴 NỘI BỘ thư viện — không xuất ra ngoài. Nơi dùng đi qua `LibsUiGridLayoutService`, ở đó mỗi
+ * thao tác sửa bố cục vừa vẽ lại vừa bắn `outChange` đúng MỘT lần. Các hàm ở đây cố tình KHÔNG tự
+ * vẽ lại: để chúng tự gọi thì mỗi thao tác vẽ hai lượt và bắn hai sự kiện (người dùng chốt
+ * 28/08/2026: "đặt đúng các điểm mà làm cho layout có thể thay đổi thôi").
+ */
+export class LibsUiGridLayoutTreeService {
+    findById(node, id) {
+        if (node.id === id) {
+            return node;
+        }
+        for (const child of node.children ?? []) {
+            const found = this.findById(child, id);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    findParent(node, id) {
+        for (const child of node.children ?? []) {
+            if (child.id === id) {
+                return node;
+            }
+            const found = this.findParent(child, id);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Thêm khối vào cuối một container. Thư viện tự sinh `id` và tự đặt `x` · `y` xuống hàng trống.
+     *
+     * @returns khối vừa tạo (kèm `id` vừa sinh), hoặc `undefined` khi không tìm thấy container.
+     */
+    addChild(root, parentId, item) {
+        const parent = this.findById(root, parentId);
+        if (!parent) {
+            return undefined;
+        }
+        parent.children = parent.children ?? [];
+        // 🔴 Thư viện tự sinh `id`. Đây là mã máy dùng để tra cứu, không phải thứ người dùng nghĩ ra —
+        // bắt họ tự đặt là mời họ tạo trùng, mà trùng id thì `findById` trả nhầm khối và cả cây hỏng
+        // im lặng (người dùng chốt 28/08/2026).
+        const node = { ...item, id: item.id ?? uuid(), x: 0, y: this.nextFreeRow(parent.children) };
+        parent.children.push(node);
+        // Trả về khối vừa tạo để nơi dùng biết `id` thư viện vừa sinh.
+        return node;
+    }
+    /** Xoá một khối khỏi cây. Không cho xoá gốc. */
+    removeById(root, id) {
+        if (root.id === id) {
+            return false;
+        }
+        const parent = this.findParent(root, id);
+        if (!parent?.children) {
+            return false;
+        }
+        parent.children = parent.children.filter((item) => item.id !== id);
+        return true;
+    }
+    /**
+     * Chuyển một khối đơn thành CONTAINER: nội dung cũ trở thành khối con đầu tiên.
+     *
+     * Không mất dữ liệu — `data` của khối được mang theo xuống khối con.
+     *
+     * @returns `false` khi không tìm thấy khối, hoặc khối đã là container rồi.
+     */
+    toContainer(root, id, colCount) {
+        const node = this.findById(root, id);
+        if (!node || (node.children?.length ?? 0) > 0) {
+            return false;
+        }
+        node.children = [{ ...node, id: uuid(), x: 0, y: 0, cols: colCount, rows: 4, children: [] }];
+        return true;
+    }
+    /**
+     * Chuyển một CONTAINER về khối đơn: các khối con được NÂNG lên cấp trên, không bị xoá.
+     *
+     * @returns `false` khi không tìm thấy khối, hoặc khối vốn không phải container.
+     */
+    toSingle(root, id) {
+        const node = this.findById(root, id);
+        if (!node || (node.children?.length ?? 0) === 0) {
+            return false;
+        }
+        const parent = this.findParent(root, id);
+        for (const child of node.children ?? []) {
+            parent?.children?.push({ ...child, cols: node.cols, rows: 2 });
+        }
+        node.children = [];
+        return true;
+    }
+    /**
+     * Làm phẳng mọi container lồng vượt trần.
+     *
+     * 🔴 Cần thiết vì bố cục ĐÃ LƯU không đi qua luật chặn nào của giao diện. Một bản lưu cũ — sinh
+     * trước khi có trần, hoặc do thao tác lỗi — vẫn nạp thẳng vào và hiện container lồng container.
+     * Container vượt trần bị hạ thành khối thường, con của nó nâng lên cấp trên: KHÔNG mất dữ liệu.
+     *
+     * @returns số container đã làm phẳng
+     */
+    flattenOverDepthContainers(node, maxDepth) {
+        return this.walkFlatten(node, 0, maxDepth);
+    }
+    /**
+     * Dồn khối khít lên trên theo thứ tự đọc, lấp hết chỗ trống.
+     *
+     * 🔴 KHÔNG sửa `node.rows` của container. Chiều cao container tính theo đơn vị hàng của lưới CHA,
+     * còn `currentRow` đếm theo đơn vị hàng của lưới CON — trộn hai thang đo là container phình lên
+     * gấp mấy lần.
+     */
+    compact(node, colCount) {
+        this.walkCompact(node, colCount);
+    }
+    walkCompact(node, colCount) {
+        const children = node.children;
+        if (!children?.length) {
+            return;
+        }
+        const inReadingOrder = [...children].sort((a, b) => a.y - b.y || a.x - b.x);
+        let currentRow = 0;
+        let usedCols = 0;
+        let tallestInRow = 0;
+        for (const item of inReadingOrder) {
+            const width = Math.min(item.cols, colCount);
+            if (usedCols > 0 && usedCols + width > colCount) {
+                currentRow += tallestInRow;
+                usedCols = 0;
+                tallestInRow = 0;
+            }
+            item.x = usedCols;
+            item.y = currentRow;
+            item.cols = width;
+            usedCols += width;
+            tallestInRow = Math.max(tallestInRow, item.rows);
+            if ((item.children?.length ?? 0) > 0) {
+                this.walkCompact(item, colCount);
+            }
+        }
+    }
+    walkFlatten(node, containerDepth, maxDepth) {
+        const children = node.children;
+        if (!children?.length) {
+            return 0;
+        }
+        let fixedCount = 0;
+        const result = [];
+        for (const child of children) {
+            const isContainer = (child.children?.length ?? 0) > 0;
+            if (isContainer && containerDepth >= maxDepth) {
+                fixedCount += 1;
+                for (const item of child.children ?? []) {
+                    fixedCount += this.walkFlatten(item, containerDepth, maxDepth);
+                    result.push(item);
+                }
+                continue;
+            }
+            fixedCount += this.walkFlatten(child, isContainer ? containerDepth + 1 : containerDepth, maxDepth);
+            result.push(child);
+        }
+        node.children = result;
+        return fixedCount;
+    }
+    nextFreeRow(children) {
+        return children.reduce((max, child) => Math.max(max, child.y + child.rows), 0);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutTreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutTreeService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutTreeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.service.js","sourceRoot":"","sources":["../../../../../libs-ui/services/grid-layout/src/tree.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { uuid } from '@libs-ui/utils';\nimport { T_gridLayout_newNode, T_gridLayout_node } from './interfaces/grid-layout.interface';\n\n/**\n * Thao tác trên cây khối: tìm, thêm, xoá, dồn khít, chặn lồng cấp quá sâu.\n *\n * 🔴 NỘI BỘ thư viện — không xuất ra ngoài. Nơi dùng đi qua `LibsUiGridLayoutService`, ở đó mỗi\n * thao tác sửa bố cục vừa vẽ lại vừa bắn `outChange` đúng MỘT lần. Các hàm ở đây cố tình KHÔNG tự\n * vẽ lại: để chúng tự gọi thì mỗi thao tác vẽ hai lượt và bắn hai sự kiện (người dùng chốt\n * 28/08/2026: \"đặt đúng các điểm mà làm cho layout có thể thay đổi thôi\").\n */\n@Injectable()\nexport class LibsUiGridLayoutTreeService {\n  findById(node: T_gridLayout_node, id: string): T_gridLayout_node | undefined {\n    if (node.id === id) {\n      return node;\n    }\n\n    for (const child of node.children ?? []) {\n      const found = this.findById(child, id);\n\n      if (found) {\n        return found;\n      }\n    }\n\n    return undefined;\n  }\n\n  findParent(node: T_gridLayout_node, id: string): T_gridLayout_node | undefined {\n    for (const child of node.children ?? []) {\n      if (child.id === id) {\n        return node;\n      }\n\n      const found = this.findParent(child, id);\n\n      if (found) {\n        return found;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Thêm khối vào cuối một container. Thư viện tự sinh `id` và tự đặt `x` · `y` xuống hàng trống.\n   *\n   * @returns khối vừa tạo (kèm `id` vừa sinh), hoặc `undefined` khi không tìm thấy container.\n   */\n  addChild(root: T_gridLayout_node, parentId: string, item: T_gridLayout_newNode): T_gridLayout_node | undefined {\n    const parent = this.findById(root, parentId);\n\n    if (!parent) {\n      return undefined;\n    }\n\n    parent.children = parent.children ?? [];\n    // 🔴 Thư viện tự sinh `id`. Đây là mã máy dùng để tra cứu, không phải thứ người dùng nghĩ ra —\n    // bắt họ tự đặt là mời họ tạo trùng, mà trùng id thì `findById` trả nhầm khối và cả cây hỏng\n    // im lặng (người dùng chốt 28/08/2026).\n    const node: T_gridLayout_node = { ...item, id: item.id ?? uuid(), x: 0, y: this.nextFreeRow(parent.children) };\n\n    parent.children.push(node);\n\n    // Trả về khối vừa tạo để nơi dùng biết `id` thư viện vừa sinh.\n    return node;\n  }\n\n  /** Xoá một khối khỏi cây. Không cho xoá gốc. */\n  removeById(root: T_gridLayout_node, id: string): boolean {\n    if (root.id === id) {\n      return false;\n    }\n\n    const parent = this.findParent(root, id);\n\n    if (!parent?.children) {\n      return false;\n    }\n\n    parent.children = parent.children.filter((item) => item.id !== id);\n\n    return true;\n  }\n\n  /**\n   * Chuyển một khối đơn thành CONTAINER: nội dung cũ trở thành khối con đầu tiên.\n   *\n   * Không mất dữ liệu — `data` của khối được mang theo xuống khối con.\n   *\n   * @returns `false` khi không tìm thấy khối, hoặc khối đã là container rồi.\n   */\n  toContainer(root: T_gridLayout_node, id: string, colCount: number): boolean {\n    const node = this.findById(root, id);\n\n    if (!node || (node.children?.length ?? 0) > 0) {\n      return false;\n    }\n\n    node.children = [{ ...node, id: uuid(), x: 0, y: 0, cols: colCount, rows: 4, children: [] }];\n\n    return true;\n  }\n\n  /**\n   * Chuyển một CONTAINER về khối đơn: các khối con được NÂNG lên cấp trên, không bị xoá.\n   *\n   * @returns `false` khi không tìm thấy khối, hoặc khối vốn không phải container.\n   */\n  toSingle(root: T_gridLayout_node, id: string): boolean {\n    const node = this.findById(root, id);\n\n    if (!node || (node.children?.length ?? 0) === 0) {\n      return false;\n    }\n\n    const parent = this.findParent(root, id);\n\n    for (const child of node.children ?? []) {\n      parent?.children?.push({ ...child, cols: node.cols, rows: 2 });\n    }\n\n    node.children = [];\n\n    return true;\n  }\n\n  /**\n   * Làm phẳng mọi container lồng vượt trần.\n   *\n   * 🔴 Cần thiết vì bố cục ĐÃ LƯU không đi qua luật chặn nào của giao diện. Một bản lưu cũ — sinh\n   * trước khi có trần, hoặc do thao tác lỗi — vẫn nạp thẳng vào và hiện container lồng container.\n   * Container vượt trần bị hạ thành khối thường, con của nó nâng lên cấp trên: KHÔNG mất dữ liệu.\n   *\n   * @returns số container đã làm phẳng\n   */\n  flattenOverDepthContainers(node: T_gridLayout_node, maxDepth: number): number {\n    return this.walkFlatten(node, 0, maxDepth);\n  }\n\n  /**\n   * Dồn khối khít lên trên theo thứ tự đọc, lấp hết chỗ trống.\n   *\n   * 🔴 KHÔNG sửa `node.rows` của container. Chiều cao container tính theo đơn vị hàng của lưới CHA,\n   * còn `currentRow` đếm theo đơn vị hàng của lưới CON — trộn hai thang đo là container phình lên\n   * gấp mấy lần.\n   */\n  compact(node: T_gridLayout_node, colCount: number): void {\n    this.walkCompact(node, colCount);\n  }\n\n  private walkCompact(node: T_gridLayout_node, colCount: number): void {\n    const children = node.children;\n\n    if (!children?.length) {\n      return;\n    }\n\n    const inReadingOrder = [...children].sort((a, b) => a.y - b.y || a.x - b.x);\n    let currentRow = 0;\n    let usedCols = 0;\n    let tallestInRow = 0;\n\n    for (const item of inReadingOrder) {\n      const width = Math.min(item.cols, colCount);\n\n      if (usedCols > 0 && usedCols + width > colCount) {\n        currentRow += tallestInRow;\n        usedCols = 0;\n        tallestInRow = 0;\n      }\n\n      item.x = usedCols;\n      item.y = currentRow;\n      item.cols = width;\n      usedCols += width;\n      tallestInRow = Math.max(tallestInRow, item.rows);\n\n      if ((item.children?.length ?? 0) > 0) {\n        this.walkCompact(item, colCount);\n      }\n    }\n  }\n\n  private walkFlatten(node: T_gridLayout_node, containerDepth: number, maxDepth: number): number {\n    const children = node.children;\n\n    if (!children?.length) {\n      return 0;\n    }\n\n    let fixedCount = 0;\n    const result: Array<T_gridLayout_node> = [];\n\n    for (const child of children) {\n      const isContainer = (child.children?.length ?? 0) > 0;\n\n      if (isContainer && containerDepth >= maxDepth) {\n        fixedCount += 1;\n\n        for (const item of child.children ?? []) {\n          fixedCount += this.walkFlatten(item, containerDepth, maxDepth);\n          result.push(item);\n        }\n\n        continue;\n      }\n\n      fixedCount += this.walkFlatten(child, isContainer ? containerDepth + 1 : containerDepth, maxDepth);\n      result.push(child);\n    }\n\n    node.children = result;\n\n    return fixedCount;\n  }\n\n  private nextFreeRow(children: Array<T_gridLayout_node>): number {\n    return children.reduce((max, child) => Math.max(max, child.y + child.rows), 0);\n  }\n}\n"]}