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

package/esm2022/grid-layout.service.mjs

@@ -0,0 +1,433 @@
+import { DestroyRef, Injectable, inject, signal } from '@angular/core';
+import { cloneDeep } from '@libs-ui/utils';
+import { take } from 'rxjs';
+import { gridLayoutNestedConfig, gridLayoutRootConfig } from './defines/gridster-config.define';
+import { LibsUiGridLayoutTreeService } from './tree.service';
+import * as i0 from "@angular/core";
+/**
+ * Dựng một mặt phẳng kéo thả và tự gắn component của nơi dùng lên từng khối.
+ *
+ * Nơi dùng chỉ cần đưa vào: loại component muốn dựng
+ * (`nodeComponentType`) và cây dữ liệu (`data`). Toàn bộ việc vẽ lưới, kéo thả, đổi kích thước,
+ * lồng container và dọn dẹp do thư viện lo.
+ *
+ * 🔴 Đây là service theo TỪNG mặt phẳng, KHÔNG `providedIn: 'root'`. Khai trong `providers` của
+ * component dùng nó; hai mặt phẳng trên cùng một màn phải là hai thực thể riêng, dùng chung thì
+ * `componentRefs` của mặt phẳng này bị mặt phẳng kia dọn mất.
+ */
+export class LibsUiGridLayoutService {
+    // 🔴 TỰ TẠO, không `inject`. Nơi dùng chỉ phải viết `providers: [LibsUiGridLayoutService]` —
+    // không phải biết bên trong thư viện còn service nào khác (người dùng chốt 28/08/2026).
+    // `TreeService` không giữ trạng thái dùng chung nên mỗi mặt phẳng một bản là đúng.
+    treeService = new LibsUiGridLayoutTreeService();
+    /** Lượt tải component đang chờ, theo id khối — để huỷ khi khối bị gỡ giữa chừng. */
+    pendingLoads = new Map();
+    constructor() {
+        // 🔴 Service khai trong `providers` của component nên Angular huỷ nó cùng component — thư viện
+        // tự dọn ở đây, nơi dùng KHÔNG phải gọi `destroy()` trong `ngOnDestroy` (người dùng chốt
+        // 28/08/2026). Bắt nhớ một bước dọn dẹp là kiểu API dễ quên, và quên thì rò rỉ bộ nhớ im lặng.
+        inject(DestroyRef).onDestroy(() => this.destroy());
+    }
+    config;
+    componentRefs = new Map();
+    rootNode = signal(undefined);
+    editMode = signal(false);
+    /** tăng mỗi lần cây đổi — component con đọc để biết phải tính lại */
+    version = signal(0);
+    /**
+     * Signal chỉ đọc để nơi dùng theo dõi.
+     *
+     * 🔴 Là THUỘC TÍNH, không phải getter. Getter trả signal thì chỗ đọc phải viết `Version()()` —
+     * quên cặp ngoặc thứ hai là computed KHÔNG phụ thuộc vào nó, cây đổi mà lưới đứng im, và
+     * TypeScript không hề báo lỗi (đo 28/08/2026: thêm khối không hiện, sắp gọn không nhúc nhích).
+     */
+    Root = this.rootNode.asReadonly();
+    IsEditMode = this.editMode.asReadonly();
+    /** tăng mỗi lần cây hoặc cấu hình đổi */
+    Version = this.version.asReadonly();
+    /**
+     * trần số cấp container lồng nhau — canvas đọc để biết có cho chuyển thành container không */
+    maxContainerDepth() {
+        return this.config?.maxContainerDepth ?? 1;
+    }
+    /**
+     * lề trong của container, px — canvas đọc để đặt padding lên vỏ container */
+    containerPadding() {
+        return this.config?.containerPadding ?? 12;
+    }
+    /** Khởi tạo mặt phẳng. Gọi lại sẽ dọn sạch component cũ rồi dựng lại từ đầu. */
+    init(config) {
+        this.destroy();
+        this.config = config;
+        this.assignOverlapLayers(config.data);
+        // 🔴 Nhân bản như `refresh()`: `init()` lại (đổi chế độ, bật/tắt chồng khối) trên CÙNG object cây
+        // thì `@for` không dựng lại `gridster-item`, nên `layerIndex` vừa gán không tới `$item` và khối
+        // vẫn không đè nhau được (đo 28/08/2026: `item.layerIndex` = 1|2|3|4|7 mà `$item.layerIndex`
+        // toàn `undefined`).
+        this.rootNode.set(this.shallowCloneTree(config.data));
+        this.editMode.set(config.isEditMode ?? false);
+        this.version.update((v) => v + 1);
+    }
+    setEditMode(value) {
+        this.editMode.set(value);
+        // 🔴 PHẢI bơm `version`: `gridsterOptions()` đọc `editMode` để bật/tắt kéo–thả, mà computed
+        // `gridOptions` bên canvas chỉ chạy lại khi `Version` đổi. Thiếu dòng này thì đổi chế độ xong
+        // gridster vẫn giữ options cũ — chuyển sang XEM mà khối vẫn kéo được.
+        this.version.update((v) => v + 1);
+    }
+    /**
+     * Bật/tắt cho khối chồng lên nhau — KHÔNG dựng lại mặt phẳng.
+     *
+     * Trước đây nơi dùng phải gọi `init()` lại để đổi cờ này, mà `init()` huỷ sạch rồi dựng lại mọi
+     * component nội dung — lãng phí, và người dùng thấy màn chớp (người dùng chốt 28/08/2026).
+     */
+    setAllowOverlap(value) {
+        if (!this.config) {
+            return;
+        }
+        this.config = { ...this.config, allowOverlap: value };
+        const root = this.rootNode();
+        if (!root) {
+            return;
+        }
+        // 🔴 Gán lớp vào CÂY ĐANG VẼ (`rootNode`), KHÔNG phải `config.data`.
+        // `init()` đã clone `config.data` sang `rootNode` nên hai object KHÁC nhau; gán vào `config.data`
+        // thì `refresh()` clone lại từ `rootNode` — lớp vừa gán không tới `gridster-item` nào, `z-index`
+        // của mọi khối đứng ở `1` và khối nào vẽ sau thì nằm trên: chồng khối "lúc được lúc không"
+        // (đo 04/09/2026: `item.layerIndex` undefined, `getLayerIndex()` = 0 cho cả 8 khối).
+        this.assignOverlapLayers(root);
+        // Thay tham chiếu cây để `layerIndex` vừa gán tới được `$item` của gridster; component nội dung
+        // KHÔNG bị dựng lại vì `attachNode` nhận ra id cũ và chỉ `setInput`.
+        this.refresh();
+    }
+    /**
+     *
+     * Cấu hình gridster cho một cấp lưới.
+     *
+     * @param depth 0 = lưới cấp trang, ≥ 1 = lưới lồng trong container
+     */
+    buildGridsterOptions(depth, itemChangeCallback) {
+        const base = depth === 0 ? gridLayoutRootConfig() : gridLayoutNestedConfig();
+        const config = this.config;
+        if (!config) {
+            return base;
+        }
+        const isFreeMode = config.mode === "free" /* E_gridLayout_mode_string.free */;
+        const canEdit = this.editMode();
+        const canOverlap = isFreeMode || (config.allowOverlap ?? false);
+        return {
+            ...base,
+            ...(config.cols ? { minCols: config.cols, maxCols: config.cols, maxItemCols: config.cols } : {}),
+            ...(config.rowHeight && depth === 0 ? { fixedRowHeight: config.rowHeight } : {}),
+            // Khe và chiều cao hàng khác nhau theo cấp: lưới trang thoáng, lưới lồng khít.
+            ...(depth === 0 && config.margin !== undefined ? { margin: config.margin } : {}),
+            ...(depth > 0 && config.nestedMargin !== undefined ? { margin: config.nestedMargin } : {}),
+            ...(depth > 0 && config.nestedRowHeight !== undefined ? { fixedRowHeight: config.nestedRowHeight } : {}),
+            ...(depth === 0 && config.outerMargin !== undefined ? { outerMargin: config.outerMargin } : {}),
+            ...(depth === 0 && config.outerMarginBottom !== undefined ? { outerMarginBottom: config.outerMarginBottom } : {}),
+            ...(config.minItemRows !== undefined ? { minItemRows: config.minItemRows } : {}),
+            ...(config.defaultItemCols !== undefined ? { defaultItemCols: config.defaultItemCols } : {}),
+            ...(config.defaultItemRows !== undefined ? { defaultItemRows: config.defaultItemRows } : {}),
+            // 🔴 Chế độ XEM phải TẮT hẳn kéo và đổi kích thước.
+            // `base` luôn để `enabled: true`; không ghi đè theo `editMode` thì người xem vẫn kéo được khối
+            // và đổi bố cục của người khác (người dùng báo 28/08/2026: "đang xem mà vẫn kéo thả thay đổi
+            // vị trí và thêm khối được").
+            draggable: { ...base.draggable, enabled: canEdit },
+            resizable: { ...base.resizable, enabled: canEdit },
+            // Chế độ tự do LUÔN cho chồng; chế độ lưới thì theo cờ của nơi dùng.
+            allowMultiLayer: canOverlap,
+            // 🔴 Bật `allowMultiLayer` MỘT MÌNH không đủ. Mã lib so `layerIndex` của hai khối: KHÁC nhau
+            // thì cho đè, GIỐNG nhau vẫn báo va chạm. Khối không khai `layerIndex` đều rơi về
+            // `defaultLayerIndex` — tức cùng lớp, và vẫn bị đẩy nhau như lưới thường (người dùng báo
+            // 28/08/2026: "bật chồng khối nhưng khi kéo thì các khối vẫn di chuyển theo").
+            // Cho chồng thì phải TẮT đẩy khối, nếu không khối bị dạt đi trước khi kịp đè lên nhau.
+            ...(canOverlap ? { pushItems: false, pushResizeItems: false, swap: false, swapWhileDragging: false } : {}),
+            itemChangeCallback: (item) => {
+                // 🔴 Khối vừa thao tác phải lên LỚP TRÊN CÙNG.
+                // `layerIndex` gán một lần theo thứ tự cây lúc khởi tạo, nên khối kéo lên chỉ nổi TRONG LÚC
+                // kéo (nhờ `z-index: 30` của lớp `gridster-item-moving`); thả tay ra là về lớp cũ và bị khối
+                // đứng sau trong cây đè ngược lên (người dùng báo 28/08/2026, đo được: kéo z=30, thả về
+                // z=10 trong khi hai khối kế bên đang z=11 và z=12).
+                if (canOverlap) {
+                    this.raiseToTopLayer(item);
+                }
+                this.version.update((v) => v + 1);
+                itemChangeCallback?.();
+            },
+        };
+    }
+    /**
+     *
+     * Gắn component của nơi dùng lên một khối.
+     *
+     * @param host chỗ gắn RIÊNG của ô đó — mỗi khối một `ViewContainerRef`, dùng chung một cái thì
+     *   mọi component bị dồn hết vào một ô.
+     */
+    attachNode(node, depth, host) {
+        const config = this.config;
+        if (!config) {
+            return;
+        }
+        const existing = this.componentRefs.get(node.id);
+        if (existing) {
+            this.applyInputs(existing, node, depth);
+            return;
+        }
+        // Khối tự khai thì hỏi nó; không thì hỏi hàm phân giải chung. Cả hai đều nhận `node` để đọc
+        // được `data.type` mà quyết định trả component nào.
+        const stream = (node.getComponentOutlet ?? config.getComponentOutlet)?.(node);
+        if (!stream) {
+            return;
+        }
+        // 🔴 Huỷ lượt tải CŨ của đúng khối này trước khi mở lượt mới.
+        // Khối bị gỡ rồi gắn lại (đổi bố cục, sắp gọn) trong lúc `import()` chưa xong thì lượt cũ vẫn
+        // chạy tiếp và dựng component vào một `ViewContainerRef` đã chết.
+        this.pendingLoads.get(node.id)?.unsubscribe();
+        const sub = stream.pipe(take(1)).subscribe((componentType) => {
+            this.pendingLoads.delete(node.id);
+            // Khối có thể đã bị xoá trong lúc chờ tải — dựng vào đây là rò rỉ.
+            if (!this.treeService.findById(this.rootNode() ?? node, node.id)) {
+                return;
+            }
+            const ref = host.createComponent(componentType);
+            this.applyInputs(ref, node, depth);
+            this.componentRefs.set(node.id, ref);
+        });
+        this.pendingLoads.set(node.id, sub);
+    }
+    /**
+     * Gỡ component của một khối và huỷ nó. */
+    detachNode(nodeId) {
+        // Khối bị gỡ khi component của nó còn đang tải — phải huỷ lượt tải, không thì nó dựng vào một
+        // `ViewContainerRef` đã chết.
+        this.pendingLoads.get(nodeId)?.unsubscribe();
+        this.pendingLoads.delete(nodeId);
+        const ref = this.componentRefs.get(nodeId);
+        if (!ref) {
+            return;
+        }
+        ref.destroy();
+        this.componentRefs.delete(nodeId);
+    }
+    destroy() {
+        for (const sub of this.pendingLoads.values()) {
+            sub.unsubscribe();
+        }
+        for (const ref of this.componentRefs.values()) {
+            ref.destroy();
+        }
+        this.pendingLoads.clear();
+        this.componentRefs.clear();
+        this.config = undefined;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────────────────
+    // Nhóm hàm cho nơi dùng CHỦ ĐỘNG gọi — không phải chờ người dùng bấm nút trên khối.
+    // Sửa cây thì dùng thẳng `TreeService` rồi gọi `refresh()` — xem demo trong core-ui.
+    // ─────────────────────────────────────────────────────────────────────────────────────────
+    /**
+     * Báo cho service biết cây vừa đổi từ bên ngoài (thêm/xoá khối, sắp gọn, nạp bố cục khác).
+     *
+     * 🔴 PHẢI thay THAM CHIẾU của node gốc, không chỉ bơm `version`.
+     * `@for … track item.id` giữ nguyên object khi id không đổi, nên `<gridster-item [item]="…">` vẫn
+     * nhận đúng object cũ và gridster không hề biết `x/y/cols/rows/layerIndex` vừa bị sửa. Bơm mỗi
+     * `version` thì computed chạy lại nhưng trả về CÙNG mảng cũ — lưới đứng im (đo 28/08/2026: bấm
+     * "Sắp gọn" cây đã dồn khít mà màn hình không nhúc nhích; bật chồng khối mà `$item.layerIndex`
+     * vẫn trống).
+     *
+     * Nhân bản NÔNG cả node gốc và danh sách con là đủ: mảng mới → `@for` dựng lại item, object con
+     * mới → gridster đọc lại toàn bộ toạ độ.
+     */
+    refresh(event) {
+        const root = event?.root ?? this.rootNode();
+        if (!root) {
+            this.version.update((v) => v + 1);
+            return;
+        }
+        if (this.config) {
+            this.config = { ...this.config, data: root };
+        }
+        this.rootNode.set(this.shallowCloneTree(root));
+        this.version.update((v) => v + 1);
+    }
+    /** Nhân bản nông theo cả chiều sâu: mỗi node và mảng `children` thành tham chiếu mới. */
+    /**
+     * Nhân bản SÂU cả cây — dùng cho `exportLayout()`.
+     *
+     * 🔴 BỎ `getComponentOutlet` khỏi bản sao: nó là một HÀM, không tuần tự hoá được nên gửi xuống
+     * backend là hỏng (`JSON.stringify` nuốt mất, `structuredClone` ném lỗi). Nạp lại thì hàm phân
+     * giải chung của cấu hình lo — component suy ra từ `data.type`, không cần lưu.
+     */
+    deepCloneTree(node) {
+        const copy = { ...node };
+        // Cắt hàm phân giải — xem chú thích trên.
+        delete copy.getComponentOutlet;
+        const { children, data, ...rest } = copy;
+        return {
+            ...rest,
+            ...(data === undefined ? {} : { data: cloneDeep(data) }),
+            ...(children ? { children: children.map((child) => this.deepCloneTree(child)) } : {}),
+        };
+    }
+    shallowCloneTree(node) {
+        if (!node.children?.length) {
+            return { ...node };
+        }
+        return { ...node, children: node.children.map((child) => this.shallowCloneTree(child)) };
+    }
+    /**
+     * Gán `layerIndex` khác nhau cho từng khối khi bật chồng khối.
+     *
+     * 🔴 `allowMultiLayer: true` MỘT MÌNH không cho khối đè nhau. Mã lib so `layerIndex` của hai khối:
+     * KHÁC nhau thì cho đè, GIỐNG nhau vẫn báo va chạm. Khối không khai `layerIndex` đều rơi về
+     * `defaultLayerIndex` — tức CÙNG lớp, nên kéo vào nhau là bị chặn y như lưới thường (người dùng
+     * báo 28/08/2026: "bật chồng khối nhưng khi kéo thì các khối vẫn di chuyển theo").
+     *
+     * Nơi dùng tự khai `layerIndex` thì giữ nguyên; ai không khai thì thư viện xếp mỗi khối một lớp
+     * theo thứ tự, đủ để mọi cặp đều khác lớp.
+     */
+    assignOverlapLayers(root) {
+        const config = this.config;
+        const canOverlap = config?.mode === "free" /* E_gridLayout_mode_string.free */ || (config?.allowOverlap ?? false);
+        if (!canOverlap) {
+            return;
+        }
+        let layer = 0;
+        const walk = (node) => {
+            for (const child of node.children ?? []) {
+                if (child.layerIndex === undefined) {
+                    layer += 1;
+                    child.layerIndex = layer;
+                }
+                walk(child);
+            }
+        };
+        walk(root);
+    }
+    /** Đưa một khối lên trên tất cả: lớp của nó = lớp lớn nhất đang có + 1. */
+    raiseToTopLayer(item) {
+        const root = this.rootNode();
+        if (!root) {
+            return;
+        }
+        let topLayer = 0;
+        const walk = (node) => {
+            for (const child of node.children ?? []) {
+                topLayer = Math.max(topLayer, child.layerIndex ?? 0);
+                walk(child);
+            }
+        };
+        walk(root);
+        // `item` gridster trả về CHÍNH là object node của cây (truyền thẳng qua `[item]`), nên gán vào
+        // đây là cây cũng đổi theo.
+        const node = item;
+        if (node.layerIndex === topLayer) {
+            return;
+        }
+        node.layerIndex = topLayer + 1;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────────────────
+    // SỬA CÂY — thư viện đã giữ cây nên bạn KHÔNG phải truyền nó vào.
+    // Mọi hàm dưới đây tự vẽ lại; không cần gọi `refresh()`.
+    // ─────────────────────────────────────────────────────────────────────────────────────────
+    /**
+     * Thêm một khối.
+     *
+     * @param item khối mới — KHÔNG cần `id` (thư viện sinh) và `x`/`y` (tự đặt xuống hàng trống).
+     * @param parentId container muốn thêm vào; bỏ trống thì thêm vào mặt phẳng gốc.
+     * @returns khối vừa tạo (kèm `id` vừa sinh), hoặc `undefined` khi không tìm thấy container.
+     */
+    addBlock(item, parentId) {
+        const root = this.rootNode();
+        const added = root ? this.treeService.addChild(root, parentId ?? root.id, item) : undefined;
+        if (added) {
+            this.refresh();
+        }
+        return added;
+    }
+    /** Xoá một khối. Xoá container là xoá cả ruột. Trả `false` khi không xoá được (vd khối gốc). */
+    removeBlock(id) {
+        const root = this.rootNode();
+        const done = root ? this.treeService.removeById(root, id) : false;
+        if (done) {
+            this.refresh();
+        }
+        return done;
+    }
+    /** Biến khối đơn thành CONTAINER — nội dung cũ thành khối con đầu tiên, không mất dữ liệu. */
+    toContainer(id) {
+        const root = this.rootNode();
+        const done = root ? this.treeService.toContainer(root, id, this.config?.cols ?? 12) : false;
+        if (done) {
+            this.refresh();
+        }
+        return done;
+    }
+    /** Đưa CONTAINER về khối đơn — khối con được nâng lên cấp trên, không bị xoá. */
+    toSingle(id) {
+        const root = this.rootNode();
+        const done = root ? this.treeService.toSingle(root, id) : false;
+        if (done) {
+            this.refresh();
+        }
+        return done;
+    }
+    /** Dồn khối khít lên trên, lấp hết chỗ trống. Đệ quy vào container. */
+    compact() {
+        const root = this.rootNode();
+        if (!root) {
+            return;
+        }
+        this.treeService.compact(root, this.config?.cols ?? 12);
+        this.refresh();
+    }
+    /**
+     * Bố cục HIỆN TẠI, đã cắt mọi tham chiếu — gửi thẳng xuống backend được.
+     *
+     * Dùng khi bấm nút Lưu. Khác `Root()` ở chỗ đây là bản SAO: nơi dùng có sửa gì trên kết quả cũng
+     * không đụng tới cây mà thư viện đang vẽ.
+     *
+     * @returns `undefined` khi mặt phẳng chưa `init()`.
+     */
+    exportLayout() {
+        const root = this.rootNode();
+        return root ? this.deepCloneTree(root) : undefined;
+    }
+    /** Tìm một khối theo id. */
+    findBlock(id) {
+        const root = this.rootNode();
+        return root ? this.treeService.findById(root, id) : undefined;
+    }
+    /** Tìm khối cha trực tiếp của một khối. */
+    findParentBlock(id) {
+        const root = this.rootNode();
+        return root ? this.treeService.findParent(root, id) : undefined;
+    }
+    /**
+     * Cổng DUY NHẤT cho canvas của thư viện. Nơi dùng KHÔNG gọi tới đây.
+     *
+     * Mọi thứ canvas cần đều là `private` để không lọt ra API công khai; gom vào một getter theo đúng
+     * khuôn `FunctionsControl` của bộ quy ước, thay vì để rải rác hàm public mà người ngoài tưởng
+     * mình phải gọi (người dùng chốt 28/08/2026).
+     */
+    get FunctionsControl() {
+        return {
+            maxContainerDepth: () => this.maxContainerDepth(),
+            containerPadding: () => this.containerPadding(),
+            gridsterOptions: (depth, cb) => this.buildGridsterOptions(depth, cb),
+            attachNode: (node, depth, host) => this.attachNode(node, depth, host),
+            detachNode: (nodeId) => this.detachNode(nodeId),
+        };
+    }
+    applyInputs(ref, node, depth) {
+        ref.setInput('data', node.data);
+        ref.setInput('node', node);
+        ref.setInput('isEditMode', this.editMode());
+        ref.setInput('depth', depth);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiGridLayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-layout.service.js","sourceRoot":"","sources":["../../../../../libs-ui/services/grid-layout/src/grid-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, DestroyRef, Injectable, ViewContainerRef, inject, signal } from '@angular/core';\nimport { GridsterConfig, GridsterItem } from 'gridster18';\nimport { cloneDeep } from '@libs-ui/utils';\nimport { Subscription, take } from 'rxjs';\nimport { gridLayoutNestedConfig, gridLayoutRootConfig } from './defines/gridster-config.define';\nimport { LibsUiGridLayoutTreeService } from './tree.service';\nimport {\n  E_gridLayout_mode_string,\n  T_gridLayout_changeEvent,\n  T_gridLayout_newNode,\n  T_gridLayout_config,\n  T_gridLayout_node,\n} from './interfaces/grid-layout.interface';\n\n/**\n * Dựng một mặt phẳng kéo thả và tự gắn component của nơi dùng lên từng khối.\n *\n * Nơi dùng chỉ cần đưa vào: loại component muốn dựng\n * (`nodeComponentType`) và cây dữ liệu (`data`). Toàn bộ việc vẽ lưới, kéo thả, đổi kích thước,\n * lồng container và dọn dẹp do thư viện lo.\n *\n * 🔴 Đây là service theo TỪNG mặt phẳng, KHÔNG `providedIn: 'root'`. Khai trong `providers` của\n * component dùng nó; hai mặt phẳng trên cùng một màn phải là hai thực thể riêng, dùng chung thì\n * `componentRefs` của mặt phẳng này bị mặt phẳng kia dọn mất.\n */\n@Injectable()\nexport class LibsUiGridLayoutService {\n  // 🔴 TỰ TẠO, không `inject`. Nơi dùng chỉ phải viết `providers: [LibsUiGridLayoutService]` —\n  // không phải biết bên trong thư viện còn service nào khác (người dùng chốt 28/08/2026).\n  // `TreeService` không giữ trạng thái dùng chung nên mỗi mặt phẳng một bản là đúng.\n  private readonly treeService = new LibsUiGridLayoutTreeService();\n  /** Lượt tải component đang chờ, theo id khối — để huỷ khi khối bị gỡ giữa chừng. */\n  private readonly pendingLoads = new Map<string, Subscription>();\n\n  constructor() {\n    // 🔴 Service khai trong `providers` của component nên Angular huỷ nó cùng component — thư viện\n    // tự dọn ở đây, nơi dùng KHÔNG phải gọi `destroy()` trong `ngOnDestroy` (người dùng chốt\n    // 28/08/2026). Bắt nhớ một bước dọn dẹp là kiểu API dễ quên, và quên thì rò rỉ bộ nhớ im lặng.\n    inject(DestroyRef).onDestroy(() => this.destroy());\n  }\n\n  private config?: T_gridLayout_config;\n  private readonly componentRefs = new Map<string, ComponentRef<unknown>>();\n\n  private readonly rootNode = signal<T_gridLayout_node | undefined>(undefined);\n  private readonly editMode = signal<boolean>(false);\n  /** tăng mỗi lần cây đổi — component con đọc để biết phải tính lại */\n  private readonly version = signal<number>(0);\n\n  /**\n   * Signal chỉ đọc để nơi dùng theo dõi.\n   *\n   * 🔴 Là THUỘC TÍNH, không phải getter. Getter trả signal thì chỗ đọc phải viết `Version()()` —\n   * quên cặp ngoặc thứ hai là computed KHÔNG phụ thuộc vào nó, cây đổi mà lưới đứng im, và\n   * TypeScript không hề báo lỗi (đo 28/08/2026: thêm khối không hiện, sắp gọn không nhúc nhích).\n   */\n  readonly Root = this.rootNode.asReadonly();\n  readonly IsEditMode = this.editMode.asReadonly();\n  /** tăng mỗi lần cây hoặc cấu hình đổi */\n  readonly Version = this.version.asReadonly();\n\n  /**\n   * trần số cấp container lồng nhau — canvas đọc để biết có cho chuyển thành container không */\n  private maxContainerDepth(): number {\n    return this.config?.maxContainerDepth ?? 1;\n  }\n\n  /**\n   * lề trong của container, px — canvas đọc để đặt padding lên vỏ container */\n  private containerPadding(): number {\n    return this.config?.containerPadding ?? 12;\n  }\n\n  /** Khởi tạo mặt phẳng. Gọi lại sẽ dọn sạch component cũ rồi dựng lại từ đầu. */\n  init(config: T_gridLayout_config): void {\n    this.destroy();\n    this.config = config;\n    this.assignOverlapLayers(config.data);\n    // 🔴 Nhân bản như `refresh()`: `init()` lại (đổi chế độ, bật/tắt chồng khối) trên CÙNG object cây\n    // thì `@for` không dựng lại `gridster-item`, nên `layerIndex` vừa gán không tới `$item` và khối\n    // vẫn không đè nhau được (đo 28/08/2026: `item.layerIndex` = 1|2|3|4|7 mà `$item.layerIndex`\n    // toàn `undefined`).\n    this.rootNode.set(this.shallowCloneTree(config.data));\n    this.editMode.set(config.isEditMode ?? false);\n    this.version.update((v) => v + 1);\n  }\n\n  setEditMode(value: boolean): void {\n    this.editMode.set(value);\n    // 🔴 PHẢI bơm `version`: `gridsterOptions()` đọc `editMode` để bật/tắt kéo–thả, mà computed\n    // `gridOptions` bên canvas chỉ chạy lại khi `Version` đổi. Thiếu dòng này thì đổi chế độ xong\n    // gridster vẫn giữ options cũ — chuyển sang XEM mà khối vẫn kéo được.\n    this.version.update((v) => v + 1);\n  }\n\n  /**\n   * Bật/tắt cho khối chồng lên nhau — KHÔNG dựng lại mặt phẳng.\n   *\n   * Trước đây nơi dùng phải gọi `init()` lại để đổi cờ này, mà `init()` huỷ sạch rồi dựng lại mọi\n   * component nội dung — lãng phí, và người dùng thấy màn chớp (người dùng chốt 28/08/2026).\n   */\n  setAllowOverlap(value: boolean): void {\n    if (!this.config) {\n      return;\n    }\n\n    this.config = { ...this.config, allowOverlap: value };\n\n    const root = this.rootNode();\n\n    if (!root) {\n      return;\n    }\n\n    // 🔴 Gán lớp vào CÂY ĐANG VẼ (`rootNode`), KHÔNG phải `config.data`.\n    // `init()` đã clone `config.data` sang `rootNode` nên hai object KHÁC nhau; gán vào `config.data`\n    // thì `refresh()` clone lại từ `rootNode` — lớp vừa gán không tới `gridster-item` nào, `z-index`\n    // của mọi khối đứng ở `1` và khối nào vẽ sau thì nằm trên: chồng khối \"lúc được lúc không\"\n    // (đo 04/09/2026: `item.layerIndex` undefined, `getLayerIndex()` = 0 cho cả 8 khối).\n    this.assignOverlapLayers(root);\n    // Thay tham chiếu cây để `layerIndex` vừa gán tới được `$item` của gridster; component nội dung\n    // KHÔNG bị dựng lại vì `attachNode` nhận ra id cũ và chỉ `setInput`.\n    this.refresh();\n  }\n\n  /**\n   *\n   * Cấu hình gridster cho một cấp lưới.\n   *\n   * @param depth 0 = lưới cấp trang, ≥ 1 = lưới lồng trong container\n   */\n  private buildGridsterOptions(depth: number, itemChangeCallback?: () => void): GridsterConfig {\n    const base = depth === 0 ? gridLayoutRootConfig() : gridLayoutNestedConfig();\n    const config = this.config;\n\n    if (!config) {\n      return base;\n    }\n\n    const isFreeMode = config.mode === E_gridLayout_mode_string.free;\n    const canEdit = this.editMode();\n    const canOverlap = isFreeMode || (config.allowOverlap ?? false);\n\n    return {\n      ...base,\n      ...(config.cols ? { minCols: config.cols, maxCols: config.cols, maxItemCols: config.cols } : {}),\n      ...(config.rowHeight && depth === 0 ? { fixedRowHeight: config.rowHeight } : {}),\n      // Khe và chiều cao hàng khác nhau theo cấp: lưới trang thoáng, lưới lồng khít.\n      ...(depth === 0 && config.margin !== undefined ? { margin: config.margin } : {}),\n      ...(depth > 0 && config.nestedMargin !== undefined ? { margin: config.nestedMargin } : {}),\n      ...(depth > 0 && config.nestedRowHeight !== undefined ? { fixedRowHeight: config.nestedRowHeight } : {}),\n      ...(depth === 0 && config.outerMargin !== undefined ? { outerMargin: config.outerMargin } : {}),\n      ...(depth === 0 && config.outerMarginBottom !== undefined ? { outerMarginBottom: config.outerMarginBottom } : {}),\n      ...(config.minItemRows !== undefined ? { minItemRows: config.minItemRows } : {}),\n      ...(config.defaultItemCols !== undefined ? { defaultItemCols: config.defaultItemCols } : {}),\n      ...(config.defaultItemRows !== undefined ? { defaultItemRows: config.defaultItemRows } : {}),\n\n      // 🔴 Chế độ XEM phải TẮT hẳn kéo và đổi kích thước.\n      // `base` luôn để `enabled: true`; không ghi đè theo `editMode` thì người xem vẫn kéo được khối\n      // và đổi bố cục của người khác (người dùng báo 28/08/2026: \"đang xem mà vẫn kéo thả thay đổi\n      // vị trí và thêm khối được\").\n      draggable: { ...base.draggable, enabled: canEdit },\n      resizable: { ...base.resizable, enabled: canEdit },\n\n      // Chế độ tự do LUÔN cho chồng; chế độ lưới thì theo cờ của nơi dùng.\n      allowMultiLayer: canOverlap,\n      // 🔴 Bật `allowMultiLayer` MỘT MÌNH không đủ. Mã lib so `layerIndex` của hai khối: KHÁC nhau\n      // thì cho đè, GIỐNG nhau vẫn báo va chạm. Khối không khai `layerIndex` đều rơi về\n      // `defaultLayerIndex` — tức cùng lớp, và vẫn bị đẩy nhau như lưới thường (người dùng báo\n      // 28/08/2026: \"bật chồng khối nhưng khi kéo thì các khối vẫn di chuyển theo\").\n      // Cho chồng thì phải TẮT đẩy khối, nếu không khối bị dạt đi trước khi kịp đè lên nhau.\n      ...(canOverlap ? { pushItems: false, pushResizeItems: false, swap: false, swapWhileDragging: false } : {}),\n\n      itemChangeCallback: (item: GridsterItem) => {\n        // 🔴 Khối vừa thao tác phải lên LỚP TRÊN CÙNG.\n        // `layerIndex` gán một lần theo thứ tự cây lúc khởi tạo, nên khối kéo lên chỉ nổi TRONG LÚC\n        // kéo (nhờ `z-index: 30` của lớp `gridster-item-moving`); thả tay ra là về lớp cũ và bị khối\n        // đứng sau trong cây đè ngược lên (người dùng báo 28/08/2026, đo được: kéo z=30, thả về\n        // z=10 trong khi hai khối kế bên đang z=11 và z=12).\n        if (canOverlap) {\n          this.raiseToTopLayer(item);\n        }\n\n        this.version.update((v) => v + 1);\n        itemChangeCallback?.();\n      },\n    };\n  }\n\n  /**\n   *\n   * Gắn component của nơi dùng lên một khối.\n   *\n   * @param host chỗ gắn RIÊNG của ô đó — mỗi khối một `ViewContainerRef`, dùng chung một cái thì\n   *   mọi component bị dồn hết vào một ô.\n   */\n  private attachNode(node: T_gridLayout_node, depth: number, host: ViewContainerRef): void {\n    const config = this.config;\n\n    if (!config) {\n      return;\n    }\n\n    const existing = this.componentRefs.get(node.id);\n\n    if (existing) {\n      this.applyInputs(existing, node, depth);\n\n      return;\n    }\n\n    // Khối tự khai thì hỏi nó; không thì hỏi hàm phân giải chung. Cả hai đều nhận `node` để đọc\n    // được `data.type` mà quyết định trả component nào.\n    const stream = (node.getComponentOutlet ?? config.getComponentOutlet)?.(node);\n\n    if (!stream) {\n      return;\n    }\n\n    // 🔴 Huỷ lượt tải CŨ của đúng khối này trước khi mở lượt mới.\n    // Khối bị gỡ rồi gắn lại (đổi bố cục, sắp gọn) trong lúc `import()` chưa xong thì lượt cũ vẫn\n    // chạy tiếp và dựng component vào một `ViewContainerRef` đã chết.\n    this.pendingLoads.get(node.id)?.unsubscribe();\n\n    const sub = stream.pipe(take(1)).subscribe((componentType) => {\n      this.pendingLoads.delete(node.id);\n\n      // Khối có thể đã bị xoá trong lúc chờ tải — dựng vào đây là rò rỉ.\n      if (!this.treeService.findById(this.rootNode() ?? node, node.id)) {\n        return;\n      }\n\n      const ref = host.createComponent(componentType);\n\n      this.applyInputs(ref, node, depth);\n      this.componentRefs.set(node.id, ref);\n    });\n\n    this.pendingLoads.set(node.id, sub);\n  }\n\n  /**\n   * Gỡ component của một khối và huỷ nó. */\n  private detachNode(nodeId: string): void {\n    // Khối bị gỡ khi component của nó còn đang tải — phải huỷ lượt tải, không thì nó dựng vào một\n    // `ViewContainerRef` đã chết.\n    this.pendingLoads.get(nodeId)?.unsubscribe();\n    this.pendingLoads.delete(nodeId);\n\n    const ref = this.componentRefs.get(nodeId);\n\n    if (!ref) {\n      return;\n    }\n\n    ref.destroy();\n    this.componentRefs.delete(nodeId);\n  }\n\n  private destroy(): void {\n    for (const sub of this.pendingLoads.values()) {\n      sub.unsubscribe();\n    }\n\n    for (const ref of this.componentRefs.values()) {\n      ref.destroy();\n    }\n\n    this.pendingLoads.clear();\n    this.componentRefs.clear();\n    this.config = undefined;\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────────────────────\n  // Nhóm hàm cho nơi dùng CHỦ ĐỘNG gọi — không phải chờ người dùng bấm nút trên khối.\n  // Sửa cây thì dùng thẳng `TreeService` rồi gọi `refresh()` — xem demo trong core-ui.\n  // ─────────────────────────────────────────────────────────────────────────────────────────\n\n  /**\n   * Báo cho service biết cây vừa đổi từ bên ngoài (thêm/xoá khối, sắp gọn, nạp bố cục khác).\n   *\n   * 🔴 PHẢI thay THAM CHIẾU của node gốc, không chỉ bơm `version`.\n   * `@for … track item.id` giữ nguyên object khi id không đổi, nên `<gridster-item [item]=\"…\">` vẫn\n   * nhận đúng object cũ và gridster không hề biết `x/y/cols/rows/layerIndex` vừa bị sửa. Bơm mỗi\n   * `version` thì computed chạy lại nhưng trả về CÙNG mảng cũ — lưới đứng im (đo 28/08/2026: bấm\n   * \"Sắp gọn\" cây đã dồn khít mà màn hình không nhúc nhích; bật chồng khối mà `$item.layerIndex`\n   * vẫn trống).\n   *\n   * Nhân bản NÔNG cả node gốc và danh sách con là đủ: mảng mới → `@for` dựng lại item, object con\n   * mới → gridster đọc lại toàn bộ toạ độ.\n   */\n  refresh(event?: T_gridLayout_changeEvent): void {\n    const root = event?.root ?? this.rootNode();\n\n    if (!root) {\n      this.version.update((v) => v + 1);\n\n      return;\n    }\n\n    if (this.config) {\n      this.config = { ...this.config, data: root };\n    }\n\n    this.rootNode.set(this.shallowCloneTree(root));\n    this.version.update((v) => v + 1);\n  }\n\n  /** Nhân bản nông theo cả chiều sâu: mỗi node và mảng `children` thành tham chiếu mới. */\n  /**\n   * Nhân bản SÂU cả cây — dùng cho `exportLayout()`.\n   *\n   * 🔴 BỎ `getComponentOutlet` khỏi bản sao: nó là một HÀM, không tuần tự hoá được nên gửi xuống\n   * backend là hỏng (`JSON.stringify` nuốt mất, `structuredClone` ném lỗi). Nạp lại thì hàm phân\n   * giải chung của cấu hình lo — component suy ra từ `data.type`, không cần lưu.\n   */\n  private deepCloneTree(node: T_gridLayout_node): T_gridLayout_node {\n    const copy: T_gridLayout_node = { ...node };\n\n    // Cắt hàm phân giải — xem chú thích trên.\n    delete copy.getComponentOutlet;\n\n    const { children, data, ...rest } = copy;\n\n    return {\n      ...rest,\n      ...(data === undefined ? {} : { data: cloneDeep(data) }),\n      ...(children ? { children: children.map((child) => this.deepCloneTree(child)) } : {}),\n    };\n  }\n\n  private shallowCloneTree(node: T_gridLayout_node): T_gridLayout_node {\n    if (!node.children?.length) {\n      return { ...node };\n    }\n\n    return { ...node, children: node.children.map((child) => this.shallowCloneTree(child)) };\n  }\n\n  /**\n   * Gán `layerIndex` khác nhau cho từng khối khi bật chồng khối.\n   *\n   * 🔴 `allowMultiLayer: true` MỘT MÌNH không cho khối đè nhau. Mã lib so `layerIndex` của hai khối:\n   * KHÁC nhau thì cho đè, GIỐNG nhau vẫn báo va chạm. Khối không khai `layerIndex` đều rơi về\n   * `defaultLayerIndex` — tức CÙNG lớp, nên kéo vào nhau là bị chặn y như lưới thường (người dùng\n   * báo 28/08/2026: \"bật chồng khối nhưng khi kéo thì các khối vẫn di chuyển theo\").\n   *\n   * Nơi dùng tự khai `layerIndex` thì giữ nguyên; ai không khai thì thư viện xếp mỗi khối một lớp\n   * theo thứ tự, đủ để mọi cặp đều khác lớp.\n   */\n  private assignOverlapLayers(root: T_gridLayout_node): void {\n    const config = this.config;\n    const canOverlap = config?.mode === E_gridLayout_mode_string.free || (config?.allowOverlap ?? false);\n\n    if (!canOverlap) {\n      return;\n    }\n\n    let layer = 0;\n    const walk = (node: T_gridLayout_node): void => {\n      for (const child of node.children ?? []) {\n        if (child.layerIndex === undefined) {\n          layer += 1;\n          child.layerIndex = layer;\n        }\n\n        walk(child);\n      }\n    };\n\n    walk(root);\n\n  }\n\n  /** Đưa một khối lên trên tất cả: lớp của nó = lớp lớn nhất đang có + 1. */\n  private raiseToTopLayer(item: GridsterItem): void {\n    const root = this.rootNode();\n\n    if (!root) {\n      return;\n    }\n\n    let topLayer = 0;\n    const walk = (node: T_gridLayout_node): void => {\n      for (const child of node.children ?? []) {\n        topLayer = Math.max(topLayer, child.layerIndex ?? 0);\n        walk(child);\n      }\n    };\n\n    walk(root);\n\n    // `item` gridster trả về CHÍNH là object node của cây (truyền thẳng qua `[item]`), nên gán vào\n    // đây là cây cũng đổi theo.\n    const node = item as unknown as T_gridLayout_node;\n\n    if (node.layerIndex === topLayer) {\n\n      return;\n    }\n\n    node.layerIndex = topLayer + 1;\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────────────────────\n  // SỬA CÂY — thư viện đã giữ cây nên bạn KHÔNG phải truyền nó vào.\n  // Mọi hàm dưới đây tự vẽ lại; không cần gọi `refresh()`.\n  // ─────────────────────────────────────────────────────────────────────────────────────────\n\n  /**\n   * Thêm một khối.\n   *\n   * @param item khối mới — KHÔNG cần `id` (thư viện sinh) và `x`/`y` (tự đặt xuống hàng trống).\n   * @param parentId container muốn thêm vào; bỏ trống thì thêm vào mặt phẳng gốc.\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  addBlock(item: T_gridLayout_newNode, parentId?: string): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n    const added = root ? this.treeService.addChild(root, parentId ?? root.id, item) : undefined;\n\n    if (added) {\n      this.refresh();\n    }\n\n    return added;\n  }\n\n  /** Xoá một khối. Xoá container là xoá cả ruột. Trả `false` khi không xoá được (vd khối gốc). */\n  removeBlock(id: string): boolean {\n    const root = this.rootNode();\n    const done = root ? this.treeService.removeById(root, id) : false;\n\n    if (done) {\n      this.refresh();\n    }\n\n    return done;\n  }\n\n  /** Biến khối đơn thành CONTAINER — nội dung cũ thành khối con đầu tiên, không mất dữ liệu. */\n  toContainer(id: string): boolean {\n    const root = this.rootNode();\n    const done = root ? this.treeService.toContainer(root, id, this.config?.cols ?? 12) : false;\n\n    if (done) {\n      this.refresh();\n    }\n\n    return done;\n  }\n\n  /** Đưa CONTAINER về khối đơn — khối con được nâng lên cấp trên, không bị xoá. */\n  toSingle(id: string): boolean {\n    const root = this.rootNode();\n    const done = root ? this.treeService.toSingle(root, id) : false;\n\n    if (done) {\n      this.refresh();\n    }\n\n    return done;\n  }\n\n  /** Dồn khối khít lên trên, lấp hết chỗ trống. Đệ quy vào container. */\n  compact(): void {\n    const root = this.rootNode();\n\n    if (!root) {\n      return;\n    }\n\n    this.treeService.compact(root, this.config?.cols ?? 12);\n    this.refresh();\n  }\n\n  /**\n   * Bố cục HIỆN TẠI, đã cắt mọi tham chiếu — gửi thẳng xuống backend được.\n   *\n   * Dùng khi bấm nút Lưu. Khác `Root()` ở chỗ đây là bản SAO: nơi dùng có sửa gì trên kết quả cũng\n   * không đụng tới cây mà thư viện đang vẽ.\n   *\n   * @returns `undefined` khi mặt phẳng chưa `init()`.\n   */\n  exportLayout(): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n\n    return root ? this.deepCloneTree(root) : undefined;\n  }\n\n  /** Tìm một khối theo id. */\n  findBlock(id: string): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n\n    return root ? this.treeService.findById(root, id) : undefined;\n  }\n\n  /** Tìm khối cha trực tiếp của một khối. */\n  findParentBlock(id: string): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n\n    return root ? this.treeService.findParent(root, id) : undefined;\n  }\n\n  /**\n   * Cổng DUY NHẤT cho canvas của thư viện. Nơi dùng KHÔNG gọi tới đây.\n   *\n   * Mọi thứ canvas cần đều là `private` để không lọt ra API công khai; gom vào một getter theo đúng\n   * khuôn `FunctionsControl` của bộ quy ước, thay vì để rải rác hàm public mà người ngoài tưởng\n   * mình phải gọi (người dùng chốt 28/08/2026).\n   */\n  get FunctionsControl() {\n    return {\n      maxContainerDepth: () => this.maxContainerDepth(),\n      containerPadding: () => this.containerPadding(),\n      gridsterOptions: (depth: number, cb?: () => void) => this.buildGridsterOptions(depth, cb),\n      attachNode: (node: T_gridLayout_node, depth: number, host: ViewContainerRef) => this.attachNode(node, depth, host),\n      detachNode: (nodeId: string) => this.detachNode(nodeId),\n    };\n  }\n\n  private applyInputs(ref: ComponentRef<unknown>, node: T_gridLayout_node, depth: number): void {\n    ref.setInput('data', node.data);\n    ref.setInput('node', node);\n    ref.setInput('isEditMode', this.editMode());\n    ref.setInput('depth', depth);\n  }\n}\n"]}

package/esm2022/index.mjs

@@ -0,0 +1,10 @@
+// Bề mặt CÔNG KHAI — chỉ những gì nơi dùng thật sự cần.
+//
+// `LibsUiGridLayoutTreeService` CỐ Ý không xuất: mọi thao tác trên cây đã có mặt trên
+// `LibsUiGridLayoutService` với chữ ký gọn hơn (không phải truyền `root` — thư viện đang giữ nó).
+// Cấu hình gridster cũng không xuất: nó đã được vá theo hàng chục lỗi đo trên sản phẩm thật, để nơi
+// dùng sửa lại là mở đường cho chính những lỗi đó quay về.
+export * from './grid-layout.service';
+export * from './canvas/grid-layout-canvas.component';
+export * from './interfaces/grid-layout.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzLXVpL3NlcnZpY2VzL2dyaWQtbGF5b3V0L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3REFBd0Q7QUFDeEQsRUFBRTtBQUNGLHNGQUFzRjtBQUN0RixrR0FBa0c7QUFDbEcsb0dBQW9HO0FBQ3BHLDJEQUEyRDtBQUMzRCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIELhu4EgbeG6t3QgQ8OUTkcgS0hBSSDigJQgY2jhu4kgbmjhu69uZyBnw6wgbsahaSBkw7luZyB0aOG6rXQgc+G7sSBj4bqnbi5cbi8vXG4vLyBgTGlic1VpR3JpZExheW91dFRyZWVTZXJ2aWNlYCBD4buQIMOdIGtow7RuZyB4deG6pXQ6IG3hu41pIHRoYW8gdMOhYyB0csOqbiBjw6J5IMSRw6MgY8OzIG3hurd0IHRyw6puXG4vLyBgTGlic1VpR3JpZExheW91dFNlcnZpY2VgIHbhu5tpIGNo4buvIGvDvSBn4buNbiBoxqFuIChraMO0bmcgcGjhuqNpIHRydXnhu4FuIGByb290YCDigJQgdGjGsCB2aeG7h24gxJFhbmcgZ2nhu68gbsOzKS5cbi8vIEPhuqV1IGjDrG5oIGdyaWRzdGVyIGPFqW5nIGtow7RuZyB4deG6pXQ6IG7DsyDEkcOjIMSRxrDhu6NjIHbDoSB0aGVvIGjDoG5nIGNo4bulYyBs4buXaSDEkW8gdHLDqm4gc+G6o24gcGjhuqltIHRo4bqtdCwgxJHhu4MgbsahaVxuLy8gZMO5bmcgc+G7rWEgbOG6oWkgbMOgIG3hu58gxJHGsOG7nW5nIGNobyBjaMOtbmggbmjhu69uZyBs4buXaSDEkcOzIHF1YXkgduG7gS5cbmV4cG9ydCAqIGZyb20gJy4vZ3JpZC1sYXlvdXQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhbnZhcy9ncmlkLWxheW91dC1jYW52YXMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcy9ncmlkLWxheW91dC5pbnRlcmZhY2UnO1xuIl19

package/esm2022/interfaces/grid-layout.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-layout.interface.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/interfaces/grid-layout.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { Type } from '@angular/core';\nimport { Observable } from 'rxjs';\n\n/** Chế độ sắp xếp khối trên mặt phẳng */\nexport const enum E_gridLayout_mode_string {\n  /** Bám lưới: khối thẳng hàng, tự đẩy nhau, sắp gọn được */\n  grid = 'grid',\n  /** Tự do: khối đặt ở toạ độ bất kỳ, chồng lên nhau thoải mái */\n  free = 'free',\n}\n\n/** Một khối trên mặt phẳng. `children` khác rỗng thì khối là CONTAINER, ruột nó là một lưới con. */\nexport type T_gridLayout_node = {\n  id: string;\n  /** cột bắt đầu (chế độ lưới) — px theo trục X (chế độ tự do) */\n  x: number;\n  /** hàng bắt đầu (chế độ lưới) — px theo trục Y (chế độ tự do) */\n  y: number;\n  /** số cột chiếm (chế độ lưới) — px chiều rộng (chế độ tự do) */\n  cols: number;\n  /** số hàng chiếm (chế độ lưới) — px chiều cao (chế độ tự do) */\n  rows: number;\n  /**\n   * Lớp chồng. Hai khối CHỒNG nhau được khi khác `layerIndex` và `allowOverlap` bật.\n   * Bỏ trống thì mọi khối cùng lớp 0 — chồng nhau bị chặn như lưới thường.\n   */\n  layerIndex?: number;\n  /** khối con; khác rỗng thì đây là container */\n  children?: Array<T_gridLayout_node>;\n  /**\n   * Component vẽ RIÊNG cho khối này, trả về dạng Observable để LAZY LOAD thật sự.\n   * Bỏ trống thì mặt phẳng hỏi `getComponentOutlet` chung của cấu hình.\n   *\n   * ```ts\n   * getComponentOutlet: (node) => from(import('./chart-card.component').then((c) => c.ChartCardComponent))\n   * ```\n   */\n  getComponentOutlet?: (node: T_gridLayout_node) => Observable<Type<unknown>>;\n  /** dữ liệu riêng của nơi dùng — thư viện KHÔNG đọc, chuyển nguyên vào input `data` của component */\n  data?: unknown;\n};\n\n/**\n * Đi kèm sự kiện của một NÚT built-in trên khối.\n *\n * Thư viện CHƯA làm gì khi bắn — nó chỉ báo \"người dùng vừa bấm nút này\". Nơi dùng quyết định:\n * - cần hỏi trước (modal xác nhận, gọi API kiểm tra) → hỏi xong rồi gọi `confirm()`;\n * - không cần hỏi → gọi `confirm()` ngay;\n * - không cho phép → không gọi gì cả.\n *\n * ```ts\n * protected handlerRemove(event: T_gridLayout_actionEvent): void {\n *   this.dialog.confirm('Xoá khối này?').subscribe((dongY) => dongY && event.confirm());\n * }\n * ```\n */\nexport type T_gridLayout_actionEvent = {\n  /** khối người dùng vừa bấm nút */\n  nodeId: string;\n  /** khối đó, khi bạn cần đọc `data` để quyết định (vd khối đang có dữ liệu thì mới hỏi) */\n  node: T_gridLayout_node;\n  /**\n   * Gọi để thư viện thực hiện thao tác. Không gọi = không làm gì.\n   *\n   * @returns `false` khi thao tác không thực hiện được (khối đã bị xoá, chạm trần lồng cấp…).\n   */\n  confirm: () => boolean;\n};\n\n/**\n * Khối MỚI truyền vào `addChild`. Khác `T_gridLayout_node` ở ba chỗ do thư viện tự lo:\n * - `id` tự sinh (mã máy dùng để tra cứu, không phải thứ người dùng nghĩ ra),\n * - `x` · `y` tự đặt xuống hàng trống kế tiếp.\n */\nexport type T_gridLayout_newNode = Omit<T_gridLayout_node, 'id' | 'x' | 'y'> & {\n  /** để trống thì thư viện sinh; chỉ truyền khi bạn CẦN một id cố định (vd khôi phục từ bản lưu) */\n  id?: string;\n  x?: number;\n  y?: number;\n};\n\n/**\n * Đi kèm sự kiện bấm nút THÊM trên một container.\n *\n * Khác `T_gridLayout_actionEvent` ở chỗ `confirm` nhận khối muốn thêm: thư viện không biết sản phẩm\n * của bạn có những loại khối nào, nên bạn mở menu chọn loại rồi truyền khối đã dựng vào đây.\n */\nexport type T_gridLayout_addEvent = {\n  /** container người dùng muốn thêm khối vào */\n  nodeId: string;\n  node: T_gridLayout_node;\n  /** @returns khối vừa tạo (kèm `id` thư viện sinh), hoặc `undefined` nếu không thêm được */\n  confirm: (item: T_gridLayout_newNode) => T_gridLayout_node | undefined;\n};\n\n/**\n * Đầu vào mà thư viện truyền cho component của nơi dùng.\n * Component BẮT BUỘC khai đủ ba input này (dùng `input()`), thiếu cái nào thì `setInput` ném lỗi.\n */\nexport type T_gridLayout_nodeInputs<TData = unknown> = {\n  /** đúng `node.data` của khối — thứ nơi dùng cần nhất, nên để đầu */\n  data: TData;\n  /** cả khối, khi cần biết id · kích thước · có phải container không */\n  node: T_gridLayout_node;\n  /** đang ở chế độ sửa hay chỉ xem */\n  isEditMode: boolean;\n  /** độ sâu: 0 = gốc, 1 = khối cấp trang, 2 = khối trong container */\n  depth: number;\n};\n\n/** Cấu hình khởi tạo một mặt phẳng kéo thả */\nexport type T_gridLayout_config = {\n  /**\n   * Hàm PHÂN GIẢI component cho một khối — chỗ bạn map từ dữ liệu server sang giao diện.\n   *\n   * Mặt phẳng gọi hàm này cho MỖI khối không tự khai `getComponentOutlet`. Trả `Observable` nên\n   * `import()` động chạy được: bó mã của từng loại khối chỉ tải khi màn thật sự có khối loại đó.\n   *\n   * ```ts\n   * getComponentOutlet: (node) => {\n   *   const { type } = node.data as { type: string };\n   *\n   *   if (type === 'chart') {\n   *     return from(import('./chart-card.component').then((c) => c.ChartCardComponent));\n   *   }\n   *\n   *   return from(import('./text-card.component').then((c) => c.TextCardComponent));\n   * }\n   * ```\n   */\n  getComponentOutlet?: (node: T_gridLayout_node) => Observable<Type<unknown>>;\n  /** cây khối ban đầu */\n  data: T_gridLayout_node;\n  mode?: E_gridLayout_mode_string;\n  isEditMode?: boolean;\n  /** số cột của lưới (chế độ lưới). Mặc định 12 */\n  cols?: number;\n  /** chiều cao một hàng, px (chế độ lưới). Mặc định 56 */\n  rowHeight?: number;\n  /** khe giữa hai khối ở lưới CẤP TRANG, px. Mặc định 12 */\n  margin?: number;\n  /** khe giữa hai khối bên TRONG container, px. Mặc định 2 — khối con là dòng thông tin của cùng\n   *  một card, khe rộng làm chúng trông như card rời nhau */\n  nestedMargin?: number;\n  /** chiều cao một hàng bên TRONG container, px. Mặc định 16 — hàng nhỏ cho bước kéo mịn */\n  nestedRowHeight?: number;\n  /**\n   * Lề trong của CONTAINER, px — áp đều bốn chiều. Mặc định 12.\n   *\n   * Chỉ container có lề này; khối đơn không có, vì nó không chứa gì bên trong.\n   *\n   * 🔴 KHÔNG nên để 0: tay cầm đổi kích thước của khối con nằm sát biên container, không chừa lề\n   * thì chuột không trúng được nó và khối con mất luôn khả năng resize.\n   */\n  containerPadding?: number;\n  /** viền ngoài quanh lưới cấp trang. Mặc định bật */\n  outerMargin?: boolean;\n  /** chừa thêm bao nhiêu px dưới đáy lưới cấp trang. Mặc định 40 */\n  outerMarginBottom?: number;\n  /** số hàng tối thiểu một khối được co lại. Mặc định 2 */\n  minItemRows?: number;\n  /** kích thước mặc định của khối mới, tính theo ô lưới. Mặc định 3 cột × 2 hàng */\n  defaultItemCols?: number;\n  defaultItemRows?: number;\n  /**\n   * Cho phép hai khối KHÁC `layerIndex` nằm chồng nhau.\n   * Chế độ `tuDo` luôn bật, không đọc cờ này.\n   */\n  allowOverlap?: boolean;\n  /** trần số cấp container lồng nhau. Mặc định 1 (container không chứa container) */\n  maxContainerDepth?: number;\n};\n\n/** Sự kiện thư viện bắn ra khi bố cục đổi */\nexport type T_gridLayout_changeEvent = {\n  root: T_gridLayout_node;\n  /** khối vừa bị tác động; bỏ trống khi đổi diện rộng (sắp gọn, nạp lại) */\n  nodeId?: string;\n};\n"]}

package/esm2022/libs-ui-services-grid-layout.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlicy11aS1zZXJ2aWNlcy1ncmlkLWxheW91dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMtdWkvc2VydmljZXMvZ3JpZC1sYXlvdXQvc3JjL2xpYnMtdWktc2VydmljZXMtZ3JpZC1sYXlvdXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=