@libs-ui/services-grid-layout 0.2.357-26 → 0.2.357-28

package/esm2022/grid-layout.service.mjs

@@ -108,6 +108,23 @@ export class LibsUiGridLayoutService {
         // gridster vẫn giữ options cũ — chuyển sang XEM mà khối vẫn kéo được.
         this.version.update((v) => v + 1);
     }
+    /**
+     * Đổi số hàng TỐI THIỂU của lưới cấp trang — KHÔNG dựng lại mặt phẳng.
+     *
+     * 🔴 `minRows` chỉ được đọc MỘT LẦN lúc `init()`, nên nơi dùng muốn đổi nó theo chế độ (sửa thì ô
+     * li phủ kín màn, xem thì đúng số hàng của bố cục) buộc phải gọi `init()` lại — mà `init()` huỷ
+     * sạch rồi dựng lại mọi component nội dung. Hệ quả đo được 15/09/2026: mở ở chế độ xem rồi bấm
+     * Sửa thì lưới đứng ở số hàng của bố cục (28 hàng = 448px) trong khi vùng nhìn cao hơn nhiều, nên
+     * ô li ngừng ngay dưới khối cuối và phần còn lại trống trơn không có đường kẻ nào.
+     */
+    setMinRows(value) {
+        if (!this.config || !Number.isFinite(value) || value <= 0) {
+            return;
+        }
+        this.config = { ...this.config, minRows: value };
+        // Bơm `version` để `gridOptions` bên canvas tính lại — cùng lý do như `setEditMode`.
+        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.
      *
@@ -161,6 +178,7 @@ export class LibsUiGridLayoutService {
             ...(depth > 0 && config.nestedRowHeight !== undefined ? { fixedRowHeight: config.nestedRowHeight } : {}),
             ...(depth === 0 && config.outerMargin !== undefined ? { outerMargin: config.outerMargin } : {}),
             ...(depth === 0 && config.outerMarginBottom !== undefined ? { outerMarginBottom: config.outerMarginBottom } : {}),
+            ...(depth === 0 && config.outerMarginTop !== undefined ? { outerMarginTop: config.outerMarginTop } : {}),
             ...(config.minItemRows !== undefined ? { minItemRows: config.minItemRows } : {}),
             ...(config.defaultItemCols !== undefined ? { defaultItemCols: config.defaultItemCols } : {}),
             ...(config.defaultItemRows !== undefined ? { defaultItemRows: config.defaultItemRows } : {}),
@@ -734,4 +752,4 @@ export class 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, TemplateRef, ViewContainerRef, inject, signal } from '@angular/core';\nimport { GridsterComponentInterface, GridsterConfig, GridsterItem } from 'gridster18';\nimport { cloneDeep } from '@libs-ui/utils';\nimport { Subscription, take } from 'rxjs';\nimport { gridLayoutNestedConfig, gridLayoutRootConfig } from './defines/gridster-config.define';\nimport { findNodeRecursive, findParentRecursive } from './defines/collision.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   * Bộ theo dõi bề rộng của từng lưới LỒNG, để ngắt khi service bị huỷ.\n   *\n   * 🔴 Giữ tham chiếu là BẮT BUỘC: `ResizeObserver` không tự tắt theo vòng đời component. Không dọn\n   * thì mỗi lần nạp lại bố cục (đổi tab) lại chồng thêm một bộ, và chúng vẫn chạy trên DOM đã gỡ.\n   */\n  private readonly nestedResizeObservers = new Set<ResizeObserver>();\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  private readonly zoomLevel = signal<number>(1);\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  readonly Zoom = this.zoomLevel.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    // 🔴 Bố cục ĐÃ LƯU không đi qua luật chặn nào của giao diện: bản lưu cũ (sinh trước khi có trần,\n    // hoặc do thao tác lỗi) vẫn mang container lồng container. Trần `maxContainerDepth` chỉ ẩn NÚT\n    // trên canvas — nó không sửa dữ liệu, nên thiếu dòng này là vẽ ra đúng cây quá sâu đó.\n    // Nơi dùng KHÔNG tự gọi được: `LibsUiGridLayoutTreeService` cố ý không xuất.\n    this.treeService.flattenOverDepthContainers(config.data, this.maxContainerDepth());\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\n    let initialZoom = config.initialZoom ?? 1;\n    if (config.storageKey && typeof localStorage !== 'undefined') {\n      try {\n        const saved = localStorage.getItem(config.storageKey);\n        if (saved) {\n          const parsed = parseFloat(saved);\n          const min = config.zoomMin ?? 0.4;\n          const max = config.zoomMax ?? 1.5;\n          if (!isNaN(parsed) && parsed >= min && parsed <= max) {\n            initialZoom = parsed;\n          }\n        }\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n    this.zoomLevel.set(initialZoom);\n\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      scale: this.zoomLevel(),\n      ...(config.cols ? { minCols: config.cols, maxCols: config.cols, maxItemCols: config.cols } : {}),\n      ...(config.rowHeight && depth === 0 ? { fixedRowHeight: config.rowHeight } : {}),\n      ...(depth === 0 && config.minRows !== undefined ? { minRows: config.minRows } : {}),\n      ...(depth > 0 && config.nestedMinRows !== undefined ? { minRows: config.nestedMinRows } : {}),\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      ...this.buildNestedResizeHooks(base, depth),\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   * Bắt lưới LỒNG đo lại NGAY khi khung chứa nó đổi bề rộng — dùng lúc người dùng kéo mép khối cha.\n   *\n   * Gridster có sẵn đường tự đo (`resize$`), nhưng luồng đó là `switchMap(() => timer(100))`: mỗi\n   * lần phát lại huỷ timer trước, mà kéo chuột bắn dày hơn 100ms nên timer không bao giờ tới đích.\n   * Đo được (11/09/2026): kéo mép nhóm thì lưới con co theo cha từng khung hình (234 → 384 px) còn\n   * THẺ con đứng im ở 106 px suốt cú kéo, chỉ nhảy đúng sau khi thả tay.\n   *\n   * Giữ CẢ HAI đường: `itemResizeCallback` bắn đồng bộ ngay khi gridster ghi bề rộng mới lên khối\n   * (sớm hơn `ResizeObserver` một khung hình) lo độ tức thì; `ResizeObserver` lo những lần khung đổi\n   * vì lý do khác — đổi zoom, thu gọn cột bên trái.\n   *\n   * Tắt bằng `config.autoResizeNestedGrids: false`.\n   */\n  private buildNestedResizeHooks(base: GridsterConfig, depth: number): Partial<GridsterConfig> {\n    if (this.config?.autoResizeNestedGrids === false) {\n      return {};\n    }\n    const gocItemResize = base.itemResizeCallback;\n    const gocInit = base.initCallback;\n\n    return {\n      itemResizeCallback: (item, itemComponent) => {\n        gocItemResize?.(item, itemComponent);\n        const el = (itemComponent as { el?: HTMLElement } | undefined)?.el;\n\n        el?.querySelectorAll('gridster').forEach((nested) => this.resizeGridsterElement(nested as HTMLElement));\n      },\n      ...(depth > 0\n        ? { initCallback: (gridster: GridsterComponentInterface) => this.registerNestedGrid(gridster, gocInit) }\n        : {}),\n    };\n  }\n\n  /** Gọi `resize()` của một thẻ `<gridster>` qua chính instance mà nó tự gắn lên phần tử. */\n  private resizeGridsterElement(nested: HTMLElement): void {\n    const giuInstance = nested as unknown as { __gridsterInstance?: { options?: { api?: { resize?: () => void } } } };\n\n    giuInstance.__gridsterInstance?.options?.api?.resize?.();\n  }\n\n  /**\n   * Gắn instance lên chính phần tử `<gridster>` rồi theo dõi bề rộng của nó.\n   *\n   * Phải gắn ngược lên DOM vì `itemResizeCallback` của khối CHA chỉ cầm được `HTMLElement`, không có\n   * đường nào khác đi từ đó về instance của lưới lồng bên trong.\n   */\n  private registerNestedGrid(\n    gridster: GridsterComponentInterface,\n    goc?: (gridster: GridsterComponentInterface) => void\n  ): void {\n    goc?.(gridster);\n    const instance = gridster as unknown as { el?: HTMLElement; options?: { api?: { resize?: () => void } } } | undefined;\n    const el = instance?.el;\n\n    if (!el || typeof ResizeObserver === 'undefined') {\n      return;\n    }\n    (el as unknown as { __gridsterInstance?: unknown }).__gridsterInstance = instance;\n\n    const theoDoi = new ResizeObserver(() => instance?.options?.api?.resize?.());\n\n    theoDoi.observe(el);\n    this.nestedResizeObservers.add(theoDoi);\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   * @param childCanvas khuôn mặt phẳng LỒNG của khối, chỉ có với khối container tự khai\n   *   `getComponentOutlet`. Component vỏ nhận nó qua input `childCanvas` và tự đặt vào giữa tiêu đề\n   *   với phần thân của mình. Không truyền xuống thì vỏ chiếm trọn chiều cao khối và đẩy toàn bộ thẻ\n   *   con ra ngoài vùng nhìn thấy.\n   */\n  private attachNode(\n    node: T_gridLayout_node,\n    depth: number,\n    host: ViewContainerRef,\n    childCanvas?: TemplateRef<unknown>\n  ): 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, childCanvas);\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, childCanvas);\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    for (const observer of this.nestedResizeObservers) {\n      observer.disconnect();\n    }\n\n    this.pendingLoads.clear();\n    this.componentRefs.clear();\n    this.nestedResizeObservers.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  /**\n   * Thêm một khối tại toạ độ (col, row) cụ thể và tự động đẩy các khối va chạm xuống dưới.\n   */\n  insertBlockWithCollision(\n    item: T_gridLayout_newNode,\n    targetCol = 0,\n    targetRow = 0,\n    parentId?: string,\n  ): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n    const added = root\n      ? this.treeService.insertWithCollision(root, parentId ?? root.id, item, targetCol, targetRow)\n      : undefined;\n\n    if (added) {\n      this.refresh();\n    }\n\n    return added;\n  }\n\n  private readonly activeDragPayload = signal<unknown | undefined>(undefined);\n\n  /** Đặt payload khi bắt đầu kéo từ bên ngoài vào (ví dụ: palette, drawer) */\n  setDragPayload(payload: unknown): void {\n    this.activeDragPayload.set(payload);\n  }\n\n  /** Lấy payload đang kéo */\n  getDragPayload(): unknown {\n    return this.activeDragPayload();\n  }\n\n  /** Xoá payload khi kết thúc kéo */\n  clearDragPayload(): void {\n    this.activeDragPayload.set(undefined);\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  /**\n   * Số cột thật của lưới cấp trang.\n   *\n   * 🔴 Mặc định phải TRÙNG `minCols/maxCols` của `gridLayoutRootConfig()`. Trước đây chỗ này trả 24\n   * trong khi lưới vẽ 12: nơi dùng không truyền `cols` thì va chạm, `toContainer` và `compact` tính\n   * theo 24 cột còn màn hình chỉ có 12 — khối rơi ra ngoài mép phải mà không ai hiểu vì sao.\n   */\n  get totalColumns(): number {\n    return this.config?.cols ?? gridLayoutRootConfig().maxCols ?? 12;\n  }\n\n  /**\n   * Chiều cao một hàng lưới (pixel) dùng để tính khung xem trước lúc kéo thả.\n   *\n   * 🔴 Phải đọc từ `config.rowHeight` của nơi dùng. Trước đây `calculateDropGhost` đóng cứng 68, nên\n   * mặt phẳng khai hàng thấp thì khung xem trước cao gấp nhiều lần khối thật — nơi dùng phải ẩn khung\n   * của thư viện đi rồi tự vẽ lại.\n   */\n  get rowStepPx(): number {\n    return this.config?.rowHeight ?? gridLayoutRootConfig().fixedRowHeight ?? 68;\n  }\n\n  /**\n   * Khe NHÌN THẤY giữa hai khối cấp gốc (px). `0` = không áp, giữ đúng hành vi cũ.\n   */\n  get visualGapPx(): number {\n    return this.config?.visualGap ?? 0;\n  }\n\n  /**\n   * Đổi số cột / số hàng của một khối rồi vẽ lại.\n   *\n   * Kéo `cols` rộng quá mép phải thì dịch khối sang trái cho vừa, thay vì để nó tràn ra ngoài lưới.\n   */\n  resizeBlock(id: string, size: { cols?: number; rows?: number }): boolean {\n    const node = this.findBlock(id);\n\n    if (!node) {\n      return false;\n    }\n\n    if (size.cols !== undefined) {\n      node.cols = size.cols;\n      if (node.x + size.cols > this.totalColumns) {\n        node.x = Math.max(0, this.totalColumns - size.cols);\n      }\n    }\n\n    if (size.rows !== undefined) {\n      node.rows = size.rows;\n    }\n    this.refresh();\n\n    return true;\n  }\n\n  /**\n   * Nhân bản một khối — đặt kế bên phải nếu còn chỗ, không thì xuống dòng dưới.\n   *\n   * `transformData` để nơi dùng đổi phần dữ liệu riêng của mình (vd nối thêm \"(Bản sao)\" vào tiêu\n   * đề); thư viện không tự đoán trường nào là tiêu đề.\n   */\n  duplicateBlock(id: string, transformData?: (data: unknown) => unknown): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n    const node = root ? findNodeRecursive(root, id) : undefined;\n\n    if (!root || !node) {\n      return undefined;\n    }\n    const parent = findParentRecursive(root, id);\n    const isNested = Boolean(parent && parent.id !== root.id);\n    const clonedData = cloneDeep(node.data);\n\n    let targetX = node.x + node.cols;\n    let targetY = node.y;\n\n    if (targetX + node.cols > this.totalColumns) {\n      targetX = 0;\n      targetY = node.y + node.rows;\n    }\n\n    return this.addBlock(\n      {\n        x: targetX,\n        y: targetY,\n        cols: node.cols,\n        rows: node.rows,\n        data: transformData ? transformData(clonedData) : clonedData,\n        getComponentOutlet: node.getComponentOutlet,\n      },\n      isNested ? parent?.id : undefined\n    );\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.totalColumns) : 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.totalColumns);\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   * Đặt tỷ lệ thu phóng của canvas (kẹp giữa min và max).\n   *\n   * @param value Tỷ lệ (0.4 = 40%, 1.0 = 100%, 1.5 = 150%)\n   * @param persistKey Khóa localStorage để lưu lại (bỏ trống thì lấy từ config)\n   */\n  setZoom(value: number, persistKey?: string): void {\n    const min = this.config?.zoomMin ?? 0.4;\n    const max = this.config?.zoomMax ?? 1.5;\n    const clamped = Math.min(max, Math.max(min, Math.round(value * 100) / 100));\n    this.zoomLevel.set(clamped);\n\n    const storageKey = persistKey ?? this.config?.storageKey;\n    if (storageKey && typeof localStorage !== 'undefined') {\n      try {\n        localStorage.setItem(storageKey, String(clamped));\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n\n    this.version.update((v) => v + 1);\n  }\n\n  /** Phóng to thêm một bước (mặc định 0.05 tức 5%) */\n  zoomIn(step?: number, persistKey?: string): void {\n    const s = step ?? this.config?.zoomStep ?? 0.05;\n    this.setZoom(this.zoomLevel() + s, persistKey);\n  }\n\n  /** Thu nhỏ bớt một bước (mặc định 0.05 tức 5%) */\n  zoomOut(step?: number, persistKey?: string): void {\n    const s = step ?? this.config?.zoomStep ?? 0.05;\n    this.setZoom(this.zoomLevel() - s, persistKey);\n  }\n\n  /** Đặt lại tỷ lệ thu phóng gốc 100% (1.0) */\n  resetZoom(persistKey?: string): void {\n    this.setZoom(1.0, persistKey);\n  }\n\n  /**\n   * Tự động tính toán và đặt tỷ lệ thu phóng để canvas vừa vặn với chiều rộng container.\n   *\n   * @param containerWidth Chiều rộng container đo được (px)\n   * @param stageWidth Chiều rộng chuẩn của canvas (mặc định 1668px)\n   * @param padding Khoảng cách lề hai bên (mặc định 48px)\n   * @param persistKey Khóa localStorage\n   * @returns Tỷ lệ thu phóng vừa tính\n   */\n  fitToScreen(containerWidth: number, stageWidth?: number, padding = 48, persistKey?: string): number {\n    const targetWidth = stageWidth ?? this.config?.stageWidth ?? 1668;\n    const min = this.config?.zoomMin ?? 0.4;\n    const max = 1.25;\n    const ratio = Math.min(max, Math.max(min, Math.round(((containerWidth - padding) / targetWidth) * 100) / 100));\n    this.setZoom(ratio, persistKey);\n    return ratio;\n  }\n\n  /** Kiểm tra tính năng thu phóng có được cấu hình bật không */\n  isZoomConfigured(): boolean {\n    return Boolean(this.config?.enableZoom);\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      isZoomEnabled: () => this.isZoomConfigured(),\n      zoom: () => this.zoomLevel(),\n      setZoom: (v: number, key?: string) => this.setZoom(v, key),\n      zoomIn: (step?: number, key?: string) => this.zoomIn(step, key),\n      zoomOut: (step?: number, key?: string) => this.zoomOut(step, key),\n      resetZoom: (key?: string) => this.resetZoom(key),\n      fitToScreen: (cW: number, sW?: number, pad?: number, key?: string) => this.fitToScreen(cW, sW, pad, key),\n      gridsterOptions: (depth: number, cb?: () => void) => this.buildGridsterOptions(depth, cb),\n      attachNode: (node: T_gridLayout_node, depth: number, host: ViewContainerRef, childCanvas?: TemplateRef<unknown>) =>\n        this.attachNode(node, depth, host, childCanvas),\n      detachNode: (nodeId: string) => this.detachNode(nodeId),\n      getNodeElement: (nodeId: string, scope?: ParentNode) => this.getNodeElement(nodeId, scope),\n      getNodeCanvasElement: (nodeId: string, scope?: ParentNode) => this.getNodeCanvasElement(nodeId, scope),\n    };\n  }\n\n  /**\n   * Trả về vỏ DOM của một khối theo `id`.\n   *\n   * 🔴 Nơi dùng cần chạm vào DOM của khối (đo kích thước, gắn lớp phủ riêng) BẮT BUỘC đi qua đây.\n   * Trước khi có hàm này, nơi dùng phải tự viết `querySelector('.libs-ui-grid-layout-block-shell[...]')`\n   * — tức bám vào tên class NỘI BỘ của thư viện: đổi tên class là màn bên kia vỡ IM LẶNG, biên dịch\n   * vẫn xanh vì chuỗi selector không ai kiểm.\n   *\n   * `scope` giới hạn phạm vi tìm (mặc định cả tài liệu) — cần khi nhiều mặt phẳng cùng nằm trên màn.\n   */\n  getNodeElement(nodeId: string, scope?: ParentNode): HTMLElement | undefined {\n    if (typeof document === 'undefined') {\n      return undefined;\n    }\n\n    const root = scope ?? document;\n\n    return (root.querySelector(`.libs-ui-grid-layout-block-shell[data-node-id=\"${nodeId}\"]`) as HTMLElement | null) ?? undefined;\n  }\n\n  /**\n   * Trả về mặt phẳng LỒNG nằm trong một khối container (khối có con), nếu có.\n   *\n   * Tách riêng khỏi `getNodeElement` vì nơi dùng thường cần chèn phần tử của mình vào TRƯỚC mặt phẳng\n   * lồng này (ví dụ hàng tiêu đề của khối ghép), nên phải cầm đúng nó chứ không phải cả vỏ.\n   */\n  getNodeCanvasElement(nodeId: string, scope?: ParentNode): HTMLElement | undefined {\n    const shell = this.getNodeElement(nodeId, scope);\n\n    if (!shell) {\n      return undefined;\n    }\n\n    return (shell.querySelector(':scope > libs_ui-services-grid_layout-canvas') as HTMLElement | null) ?? undefined;\n  }\n\n  private applyInputs(\n    ref: ComponentRef<unknown>,\n    node: T_gridLayout_node,\n    depth: number,\n    childCanvas?: TemplateRef<unknown>\n  ): void {\n    ref.setInput('data', node.data);\n    ref.setInput('node', node);\n    ref.setInput('isEditMode', this.editMode());\n    ref.setInput('depth', depth);\n    // 🔴 CHỈ đặt khi có khuôn: `setInput` với một input component không khai là lỗi lúc chạy, mà\n    // component nội dung của khối LÁ thì không cần biết đến mặt phẳng lồng.\n    if (childCanvas) {\n      ref.setInput('childCanvas', childCanvas);\n    }\n  }\n}\n"]}
+//# 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, TemplateRef, ViewContainerRef, inject, signal } from '@angular/core';\nimport { GridsterComponentInterface, GridsterConfig, GridsterItem } from 'gridster18';\nimport { cloneDeep } from '@libs-ui/utils';\nimport { Subscription, take } from 'rxjs';\nimport { gridLayoutNestedConfig, gridLayoutRootConfig } from './defines/gridster-config.define';\nimport { findNodeRecursive, findParentRecursive } from './defines/collision.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   * Bộ theo dõi bề rộng của từng lưới LỒNG, để ngắt khi service bị huỷ.\n   *\n   * 🔴 Giữ tham chiếu là BẮT BUỘC: `ResizeObserver` không tự tắt theo vòng đời component. Không dọn\n   * thì mỗi lần nạp lại bố cục (đổi tab) lại chồng thêm một bộ, và chúng vẫn chạy trên DOM đã gỡ.\n   */\n  private readonly nestedResizeObservers = new Set<ResizeObserver>();\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  private readonly zoomLevel = signal<number>(1);\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  readonly Zoom = this.zoomLevel.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    // 🔴 Bố cục ĐÃ LƯU không đi qua luật chặn nào của giao diện: bản lưu cũ (sinh trước khi có trần,\n    // hoặc do thao tác lỗi) vẫn mang container lồng container. Trần `maxContainerDepth` chỉ ẩn NÚT\n    // trên canvas — nó không sửa dữ liệu, nên thiếu dòng này là vẽ ra đúng cây quá sâu đó.\n    // Nơi dùng KHÔNG tự gọi được: `LibsUiGridLayoutTreeService` cố ý không xuất.\n    this.treeService.flattenOverDepthContainers(config.data, this.maxContainerDepth());\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\n    let initialZoom = config.initialZoom ?? 1;\n    if (config.storageKey && typeof localStorage !== 'undefined') {\n      try {\n        const saved = localStorage.getItem(config.storageKey);\n        if (saved) {\n          const parsed = parseFloat(saved);\n          const min = config.zoomMin ?? 0.4;\n          const max = config.zoomMax ?? 1.5;\n          if (!isNaN(parsed) && parsed >= min && parsed <= max) {\n            initialZoom = parsed;\n          }\n        }\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n    this.zoomLevel.set(initialZoom);\n\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   * Đổi số hàng TỐI THIỂU của lưới cấp trang — KHÔNG dựng lại mặt phẳng.\n   *\n   * 🔴 `minRows` chỉ được đọc MỘT LẦN lúc `init()`, nên nơi dùng muốn đổi nó theo chế độ (sửa thì ô\n   * li phủ kín màn, xem thì đúng số hàng của bố cục) buộc phải gọi `init()` lại — mà `init()` huỷ\n   * sạch rồi dựng lại mọi component nội dung. Hệ quả đo được 15/09/2026: mở ở chế độ xem rồi bấm\n   * Sửa thì lưới đứng ở số hàng của bố cục (28 hàng = 448px) trong khi vùng nhìn cao hơn nhiều, nên\n   * ô li ngừng ngay dưới khối cuối và phần còn lại trống trơn không có đường kẻ nào.\n   */\n  setMinRows(value: number): void {\n    if (!this.config || !Number.isFinite(value) || value <= 0) {\n      return;\n    }\n\n    this.config = { ...this.config, minRows: value };\n    // Bơm `version` để `gridOptions` bên canvas tính lại — cùng lý do như `setEditMode`.\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      scale: this.zoomLevel(),\n      ...(config.cols ? { minCols: config.cols, maxCols: config.cols, maxItemCols: config.cols } : {}),\n      ...(config.rowHeight && depth === 0 ? { fixedRowHeight: config.rowHeight } : {}),\n      ...(depth === 0 && config.minRows !== undefined ? { minRows: config.minRows } : {}),\n      ...(depth > 0 && config.nestedMinRows !== undefined ? { minRows: config.nestedMinRows } : {}),\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      ...(depth === 0 && config.outerMarginTop !== undefined ? { outerMarginTop: config.outerMarginTop } : {}),\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      ...this.buildNestedResizeHooks(base, depth),\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   * Bắt lưới LỒNG đo lại NGAY khi khung chứa nó đổi bề rộng — dùng lúc người dùng kéo mép khối cha.\n   *\n   * Gridster có sẵn đường tự đo (`resize$`), nhưng luồng đó là `switchMap(() => timer(100))`: mỗi\n   * lần phát lại huỷ timer trước, mà kéo chuột bắn dày hơn 100ms nên timer không bao giờ tới đích.\n   * Đo được (11/09/2026): kéo mép nhóm thì lưới con co theo cha từng khung hình (234 → 384 px) còn\n   * THẺ con đứng im ở 106 px suốt cú kéo, chỉ nhảy đúng sau khi thả tay.\n   *\n   * Giữ CẢ HAI đường: `itemResizeCallback` bắn đồng bộ ngay khi gridster ghi bề rộng mới lên khối\n   * (sớm hơn `ResizeObserver` một khung hình) lo độ tức thì; `ResizeObserver` lo những lần khung đổi\n   * vì lý do khác — đổi zoom, thu gọn cột bên trái.\n   *\n   * Tắt bằng `config.autoResizeNestedGrids: false`.\n   */\n  private buildNestedResizeHooks(base: GridsterConfig, depth: number): Partial<GridsterConfig> {\n    if (this.config?.autoResizeNestedGrids === false) {\n      return {};\n    }\n    const gocItemResize = base.itemResizeCallback;\n    const gocInit = base.initCallback;\n\n    return {\n      itemResizeCallback: (item, itemComponent) => {\n        gocItemResize?.(item, itemComponent);\n        const el = (itemComponent as { el?: HTMLElement } | undefined)?.el;\n\n        el?.querySelectorAll('gridster').forEach((nested) => this.resizeGridsterElement(nested as HTMLElement));\n      },\n      ...(depth > 0\n        ? { initCallback: (gridster: GridsterComponentInterface) => this.registerNestedGrid(gridster, gocInit) }\n        : {}),\n    };\n  }\n\n  /** Gọi `resize()` của một thẻ `<gridster>` qua chính instance mà nó tự gắn lên phần tử. */\n  private resizeGridsterElement(nested: HTMLElement): void {\n    const giuInstance = nested as unknown as { __gridsterInstance?: { options?: { api?: { resize?: () => void } } } };\n\n    giuInstance.__gridsterInstance?.options?.api?.resize?.();\n  }\n\n  /**\n   * Gắn instance lên chính phần tử `<gridster>` rồi theo dõi bề rộng của nó.\n   *\n   * Phải gắn ngược lên DOM vì `itemResizeCallback` của khối CHA chỉ cầm được `HTMLElement`, không có\n   * đường nào khác đi từ đó về instance của lưới lồng bên trong.\n   */\n  private registerNestedGrid(\n    gridster: GridsterComponentInterface,\n    goc?: (gridster: GridsterComponentInterface) => void\n  ): void {\n    goc?.(gridster);\n    const instance = gridster as unknown as { el?: HTMLElement; options?: { api?: { resize?: () => void } } } | undefined;\n    const el = instance?.el;\n\n    if (!el || typeof ResizeObserver === 'undefined') {\n      return;\n    }\n    (el as unknown as { __gridsterInstance?: unknown }).__gridsterInstance = instance;\n\n    const theoDoi = new ResizeObserver(() => instance?.options?.api?.resize?.());\n\n    theoDoi.observe(el);\n    this.nestedResizeObservers.add(theoDoi);\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   * @param childCanvas khuôn mặt phẳng LỒNG của khối, chỉ có với khối container tự khai\n   *   `getComponentOutlet`. Component vỏ nhận nó qua input `childCanvas` và tự đặt vào giữa tiêu đề\n   *   với phần thân của mình. Không truyền xuống thì vỏ chiếm trọn chiều cao khối và đẩy toàn bộ thẻ\n   *   con ra ngoài vùng nhìn thấy.\n   */\n  private attachNode(\n    node: T_gridLayout_node,\n    depth: number,\n    host: ViewContainerRef,\n    childCanvas?: TemplateRef<unknown>\n  ): 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, childCanvas);\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, childCanvas);\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    for (const observer of this.nestedResizeObservers) {\n      observer.disconnect();\n    }\n\n    this.pendingLoads.clear();\n    this.componentRefs.clear();\n    this.nestedResizeObservers.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  /**\n   * Thêm một khối tại toạ độ (col, row) cụ thể và tự động đẩy các khối va chạm xuống dưới.\n   */\n  insertBlockWithCollision(\n    item: T_gridLayout_newNode,\n    targetCol = 0,\n    targetRow = 0,\n    parentId?: string,\n  ): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n    const added = root\n      ? this.treeService.insertWithCollision(root, parentId ?? root.id, item, targetCol, targetRow)\n      : undefined;\n\n    if (added) {\n      this.refresh();\n    }\n\n    return added;\n  }\n\n  private readonly activeDragPayload = signal<unknown | undefined>(undefined);\n\n  /** Đặt payload khi bắt đầu kéo từ bên ngoài vào (ví dụ: palette, drawer) */\n  setDragPayload(payload: unknown): void {\n    this.activeDragPayload.set(payload);\n  }\n\n  /** Lấy payload đang kéo */\n  getDragPayload(): unknown {\n    return this.activeDragPayload();\n  }\n\n  /** Xoá payload khi kết thúc kéo */\n  clearDragPayload(): void {\n    this.activeDragPayload.set(undefined);\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  /**\n   * Số cột thật của lưới cấp trang.\n   *\n   * 🔴 Mặc định phải TRÙNG `minCols/maxCols` của `gridLayoutRootConfig()`. Trước đây chỗ này trả 24\n   * trong khi lưới vẽ 12: nơi dùng không truyền `cols` thì va chạm, `toContainer` và `compact` tính\n   * theo 24 cột còn màn hình chỉ có 12 — khối rơi ra ngoài mép phải mà không ai hiểu vì sao.\n   */\n  get totalColumns(): number {\n    return this.config?.cols ?? gridLayoutRootConfig().maxCols ?? 12;\n  }\n\n  /**\n   * Chiều cao một hàng lưới (pixel) dùng để tính khung xem trước lúc kéo thả.\n   *\n   * 🔴 Phải đọc từ `config.rowHeight` của nơi dùng. Trước đây `calculateDropGhost` đóng cứng 68, nên\n   * mặt phẳng khai hàng thấp thì khung xem trước cao gấp nhiều lần khối thật — nơi dùng phải ẩn khung\n   * của thư viện đi rồi tự vẽ lại.\n   */\n  get rowStepPx(): number {\n    return this.config?.rowHeight ?? gridLayoutRootConfig().fixedRowHeight ?? 68;\n  }\n\n  /**\n   * Khe NHÌN THẤY giữa hai khối cấp gốc (px). `0` = không áp, giữ đúng hành vi cũ.\n   */\n  get visualGapPx(): number {\n    return this.config?.visualGap ?? 0;\n  }\n\n  /**\n   * Đổi số cột / số hàng của một khối rồi vẽ lại.\n   *\n   * Kéo `cols` rộng quá mép phải thì dịch khối sang trái cho vừa, thay vì để nó tràn ra ngoài lưới.\n   */\n  resizeBlock(id: string, size: { cols?: number; rows?: number }): boolean {\n    const node = this.findBlock(id);\n\n    if (!node) {\n      return false;\n    }\n\n    if (size.cols !== undefined) {\n      node.cols = size.cols;\n      if (node.x + size.cols > this.totalColumns) {\n        node.x = Math.max(0, this.totalColumns - size.cols);\n      }\n    }\n\n    if (size.rows !== undefined) {\n      node.rows = size.rows;\n    }\n    this.refresh();\n\n    return true;\n  }\n\n  /**\n   * Nhân bản một khối — đặt kế bên phải nếu còn chỗ, không thì xuống dòng dưới.\n   *\n   * `transformData` để nơi dùng đổi phần dữ liệu riêng của mình (vd nối thêm \"(Bản sao)\" vào tiêu\n   * đề); thư viện không tự đoán trường nào là tiêu đề.\n   */\n  duplicateBlock(id: string, transformData?: (data: unknown) => unknown): T_gridLayout_node | undefined {\n    const root = this.rootNode();\n    const node = root ? findNodeRecursive(root, id) : undefined;\n\n    if (!root || !node) {\n      return undefined;\n    }\n    const parent = findParentRecursive(root, id);\n    const isNested = Boolean(parent && parent.id !== root.id);\n    const clonedData = cloneDeep(node.data);\n\n    let targetX = node.x + node.cols;\n    let targetY = node.y;\n\n    if (targetX + node.cols > this.totalColumns) {\n      targetX = 0;\n      targetY = node.y + node.rows;\n    }\n\n    return this.addBlock(\n      {\n        x: targetX,\n        y: targetY,\n        cols: node.cols,\n        rows: node.rows,\n        data: transformData ? transformData(clonedData) : clonedData,\n        getComponentOutlet: node.getComponentOutlet,\n      },\n      isNested ? parent?.id : undefined\n    );\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.totalColumns) : 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.totalColumns);\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   * Đặt tỷ lệ thu phóng của canvas (kẹp giữa min và max).\n   *\n   * @param value Tỷ lệ (0.4 = 40%, 1.0 = 100%, 1.5 = 150%)\n   * @param persistKey Khóa localStorage để lưu lại (bỏ trống thì lấy từ config)\n   */\n  setZoom(value: number, persistKey?: string): void {\n    const min = this.config?.zoomMin ?? 0.4;\n    const max = this.config?.zoomMax ?? 1.5;\n    const clamped = Math.min(max, Math.max(min, Math.round(value * 100) / 100));\n    this.zoomLevel.set(clamped);\n\n    const storageKey = persistKey ?? this.config?.storageKey;\n    if (storageKey && typeof localStorage !== 'undefined') {\n      try {\n        localStorage.setItem(storageKey, String(clamped));\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n\n    this.version.update((v) => v + 1);\n  }\n\n  /** Phóng to thêm một bước (mặc định 0.05 tức 5%) */\n  zoomIn(step?: number, persistKey?: string): void {\n    const s = step ?? this.config?.zoomStep ?? 0.05;\n    this.setZoom(this.zoomLevel() + s, persistKey);\n  }\n\n  /** Thu nhỏ bớt một bước (mặc định 0.05 tức 5%) */\n  zoomOut(step?: number, persistKey?: string): void {\n    const s = step ?? this.config?.zoomStep ?? 0.05;\n    this.setZoom(this.zoomLevel() - s, persistKey);\n  }\n\n  /** Đặt lại tỷ lệ thu phóng gốc 100% (1.0) */\n  resetZoom(persistKey?: string): void {\n    this.setZoom(1.0, persistKey);\n  }\n\n  /**\n   * Tự động tính toán và đặt tỷ lệ thu phóng để canvas vừa vặn với chiều rộng container.\n   *\n   * @param containerWidth Chiều rộng container đo được (px)\n   * @param stageWidth Chiều rộng chuẩn của canvas (mặc định 1668px)\n   * @param padding Khoảng cách lề hai bên (mặc định 48px)\n   * @param persistKey Khóa localStorage\n   * @returns Tỷ lệ thu phóng vừa tính\n   */\n  fitToScreen(containerWidth: number, stageWidth?: number, padding = 48, persistKey?: string): number {\n    const targetWidth = stageWidth ?? this.config?.stageWidth ?? 1668;\n    const min = this.config?.zoomMin ?? 0.4;\n    const max = 1.25;\n    const ratio = Math.min(max, Math.max(min, Math.round(((containerWidth - padding) / targetWidth) * 100) / 100));\n    this.setZoom(ratio, persistKey);\n    return ratio;\n  }\n\n  /** Kiểm tra tính năng thu phóng có được cấu hình bật không */\n  isZoomConfigured(): boolean {\n    return Boolean(this.config?.enableZoom);\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      isZoomEnabled: () => this.isZoomConfigured(),\n      zoom: () => this.zoomLevel(),\n      setZoom: (v: number, key?: string) => this.setZoom(v, key),\n      zoomIn: (step?: number, key?: string) => this.zoomIn(step, key),\n      zoomOut: (step?: number, key?: string) => this.zoomOut(step, key),\n      resetZoom: (key?: string) => this.resetZoom(key),\n      fitToScreen: (cW: number, sW?: number, pad?: number, key?: string) => this.fitToScreen(cW, sW, pad, key),\n      gridsterOptions: (depth: number, cb?: () => void) => this.buildGridsterOptions(depth, cb),\n      attachNode: (node: T_gridLayout_node, depth: number, host: ViewContainerRef, childCanvas?: TemplateRef<unknown>) =>\n        this.attachNode(node, depth, host, childCanvas),\n      detachNode: (nodeId: string) => this.detachNode(nodeId),\n      getNodeElement: (nodeId: string, scope?: ParentNode) => this.getNodeElement(nodeId, scope),\n      getNodeCanvasElement: (nodeId: string, scope?: ParentNode) => this.getNodeCanvasElement(nodeId, scope),\n    };\n  }\n\n  /**\n   * Trả về vỏ DOM của một khối theo `id`.\n   *\n   * 🔴 Nơi dùng cần chạm vào DOM của khối (đo kích thước, gắn lớp phủ riêng) BẮT BUỘC đi qua đây.\n   * Trước khi có hàm này, nơi dùng phải tự viết `querySelector('.libs-ui-grid-layout-block-shell[...]')`\n   * — tức bám vào tên class NỘI BỘ của thư viện: đổi tên class là màn bên kia vỡ IM LẶNG, biên dịch\n   * vẫn xanh vì chuỗi selector không ai kiểm.\n   *\n   * `scope` giới hạn phạm vi tìm (mặc định cả tài liệu) — cần khi nhiều mặt phẳng cùng nằm trên màn.\n   */\n  getNodeElement(nodeId: string, scope?: ParentNode): HTMLElement | undefined {\n    if (typeof document === 'undefined') {\n      return undefined;\n    }\n\n    const root = scope ?? document;\n\n    return (root.querySelector(`.libs-ui-grid-layout-block-shell[data-node-id=\"${nodeId}\"]`) as HTMLElement | null) ?? undefined;\n  }\n\n  /**\n   * Trả về mặt phẳng LỒNG nằm trong một khối container (khối có con), nếu có.\n   *\n   * Tách riêng khỏi `getNodeElement` vì nơi dùng thường cần chèn phần tử của mình vào TRƯỚC mặt phẳng\n   * lồng này (ví dụ hàng tiêu đề của khối ghép), nên phải cầm đúng nó chứ không phải cả vỏ.\n   */\n  getNodeCanvasElement(nodeId: string, scope?: ParentNode): HTMLElement | undefined {\n    const shell = this.getNodeElement(nodeId, scope);\n\n    if (!shell) {\n      return undefined;\n    }\n\n    return (shell.querySelector(':scope > libs_ui-services-grid_layout-canvas') as HTMLElement | null) ?? undefined;\n  }\n\n  private applyInputs(\n    ref: ComponentRef<unknown>,\n    node: T_gridLayout_node,\n    depth: number,\n    childCanvas?: TemplateRef<unknown>\n  ): void {\n    ref.setInput('data', node.data);\n    ref.setInput('node', node);\n    ref.setInput('isEditMode', this.editMode());\n    ref.setInput('depth', depth);\n    // 🔴 CHỈ đặt khi có khuôn: `setInput` với một input component không khai là lỗi lúc chạy, mà\n    // component nội dung của khối LÁ thì không cần biết đến mặt phẳng lồng.\n    if (childCanvas) {\n      ref.setInput('childCanvas', childCanvas);\n    }\n  }\n}\n"]}

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

@@ -1,2 +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   * 🔴 Khai cho khối CÓ CON (container) là khai VỎ của khối ghép — hàng tiêu đề, nút thu gọn, nền.\n   * Vỏ KHÔNG thay thế mặt phẳng lồng bên trong: thư viện truyền mặt phẳng đó xuống component vỏ qua\n   * input `childCanvas: TemplateRef<unknown>`, và vỏ BẮT BUỘC vẽ nó ra bằng `ngTemplateOutlet`, nếu\n   * không toàn bộ khối con biến mất khỏi màn.\n   *\n   * ```html\n   * <!-- trong component vỏ -->\n   * <div class=\"flex h-full flex-col\">\n   *   <div class=\"shrink-0\">{{ title() }}</div>\n   *   <div class=\"min-h-0 flex-1\">\n   *     <ng-container [ngTemplateOutlet]=\"childCanvas()\" />\n   *   </div>\n   * </div>\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   * Bật để GIỮ `x`/`y` truyền vào. Mặc định tắt: thư viện tự xếp khối xuống hàng trống kế tiếp.\n   *\n   * 🔴 Phải là cờ tường minh, KHÔNG suy ra từ việc có truyền `x`/`y` hay không: `0` vừa là toạ độ\n   * hợp lệ vừa là giá trị mọi hàm dựng node điền sẵn, nên đoán nhầm là khối mới đè lên khối cũ.\n   *\n   * Cờ này chỉ để điều khiển lúc thêm, không được lưu lại trong cây.\n   */\n  keepPosition?: boolean;\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  /**\n   * Số hàng TỐI THIỂU của lưới CẤP TRANG. Mặc định 2.\n   *\n   * Đặt lớn hơn khi muốn ô li phủ kín màn hình ngay cả lúc bố cục còn ít khối — lưới chỉ cao bằng\n   * khối cuối cùng thì phần dưới trống trơn, người dùng không biết còn thả được vào đâu.\n   */\n  minRows?: number;\n  /** Số hàng TỐI THIỂU của lưới bên TRONG container. Mặc định 1 */\n  nestedMinRows?: number;\n  /**\n   * Cho lưới LỒNG tự đo lại khi khung chứa nó đổi bề rộng. Mặc định BẬT.\n   *\n   * Tắt đi thì lúc kéo mép khối cha, thẻ con đứng im tới khi thả tay — chỉ tắt nếu nơi dùng tự lo\n   * việc đo lại.\n   */\n  autoResizeNestedGrids?: boolean;\n  /** khe giữa hai khối ở lưới CẤP TRANG, px. Mặc định 12 */\n  margin?: number;\n  /**\n   * Khe NHÌN THẤY giữa hai khối cấp trang, px — phần vỏ khối thụt vào nửa khe mỗi cạnh.\n   *\n   * 🔴 Khác `margin`: `margin` là khe của Ô LƯỚI nên đổi nó là đổi luôn bước kéo và phép tính va\n   * chạm. Muốn thẻ trông thưa ra mà bước kéo giữ nguyên thì dùng `visualGap` — ô lưới không đổi,\n   * chỉ phần nhìn thấy co lại. Không khai thì không áp gì (giữ đúng hành vi cũ).\n   *\n   * Chỉ áp cho khối CẤP GỐC; khối con trong container giữ nguyên để không tách rời các dòng của\n   * cùng một thẻ.\n   */\n  visualGap?: 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  /** Bật tính năng thu phóng (zoom) canvas. Mặc định false */\n  enableZoom?: boolean;\n  /** Tỷ lệ thu phóng ban đầu. Mặc định 1 (100%) */\n  initialZoom?: number;\n  /** Giới hạn thu phóng tối thiểu. Mặc định 0.4 (40%) */\n  zoomMin?: number;\n  /** Giới hạn thu phóng tối đa. Mặc định 1.5 (150%) */\n  zoomMax?: number;\n  /** Bước nhảy mỗi lần tăng/giảm thu phóng. Mặc định 0.05 (5%) */\n  zoomStep?: number;\n  /** Chiều rộng chuẩn của canvas stage, px. Mặc định 1668 */\n  stageWidth?: number;\n  /** Chiều cao tối thiểu của canvas stage, px. Mặc định 937 */\n  stageMinHeight?: number;\n  /** Khóa lưu tỷ lệ thu phóng vào localStorage (vd 'ocb_bi_canvas_zoom') */\n  storageKey?: string;\n  /** Tự động vừa màn hình khi tải trang lần đầu nếu khung nhìn nhỏ hơn stage. Mặc định true */\n  autoFitOnLoad?: boolean;\n};\n\n/** Lựa chọn tỷ lệ thu phóng trên menu dropdown */\nexport type T_gridLayout_zoomPreset = {\n  /** Khoá i18n, KHÔNG phải chữ hiển thị — template dịch qua `translate` pipe. */\n  label: string;\n  value: 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\n/**\n * Bối cảnh truyền vào `templateToolbar` — template tự vẽ thanh công cụ thay bộ nút mặc định.\n *\n * ```html\n * <ng-template #toolbar let-node let-ctx=\"ctx\">\n *   <libs_ui-components-buttons-button\n *     [classIconLeft]=\"'libs-ui-icon-remove'\"\n *     (outClick)=\"ctx.remove()\" />\n * </ng-template>\n * ```\n */\nexport type T_gridLayout_toolbarContext = {\n  /** khối đang vẽ — dùng `let-node` trong template */\n  $implicit: T_gridLayout_node;\n  /** khối này là container (có ruột) hay khối đơn */\n  isContainer: boolean;\n  /** còn thêm được khối vào trong không (chưa chạm trần lồng cấp) */\n  canAddInside: boolean;\n  /** đổi được giữa khối đơn ↔ khối ghép không */\n  canToggleType: boolean;\n  /** gọi để thư viện phát `outRemoveNode` như khi bấm nút xoá mặc định */\n  remove: () => void;\n  /** gọi để thư viện phát `outAddBlockInside` */\n  addInside: () => void;\n  /** gọi để thư viện phát `outToggleType` */\n  toggleType: () => void;\n};\n\n/** Khung xem trước (ghost preview) khi kéo thẻ từ bên ngoài vào canvas */\nexport type T_gridLayout_dropGhost = {\n  col: number;\n  row: number;\n  cols: number;\n  rows: number;\n  pixelLeft: number;\n  pixelTop: number;\n  pixelWidth: number;\n  pixelHeight: number;\n  isInsideGroup: boolean;\n  targetParentId?: string;\n  groupTitle?: string;\n  cardTitle: string;\n  cardIconText?: string;\n  cardIconClass?: string;\n  hoveredGridster?: HTMLElement;\n};\n\n/** Sự kiện phát ra khi thả một thẻ mới từ bên ngoài vào canvas */\nexport type T_gridLayout_dropEvent = {\n  node: T_gridLayout_node;\n  parentId?: string;\n  col: number;\n  row: number;\n  cols: number;\n  rows: number;\n  rawEvent: DragEvent;\n  payload?: unknown;\n};\n\n/** Dữ liệu của thẻ kéo từ bên ngoài vào canvas */\nexport type T_gridLayout_externalDragPayload = {\n  kind?: string;\n  type?: string;\n  title?: string;\n  cols?: number;\n  rows?: number;\n  iconText?: string;\n  iconClass?: string;\n  data?: Record<string, unknown>;\n  [key: string]: unknown;\n};\n\n"]}
+//# 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   * 🔴 Khai cho khối CÓ CON (container) là khai VỎ của khối ghép — hàng tiêu đề, nút thu gọn, nền.\n   * Vỏ KHÔNG thay thế mặt phẳng lồng bên trong: thư viện truyền mặt phẳng đó xuống component vỏ qua\n   * input `childCanvas: TemplateRef<unknown>`, và vỏ BẮT BUỘC vẽ nó ra bằng `ngTemplateOutlet`, nếu\n   * không toàn bộ khối con biến mất khỏi màn.\n   *\n   * ```html\n   * <!-- trong component vỏ -->\n   * <div class=\"flex h-full flex-col\">\n   *   <div class=\"shrink-0\">{{ title() }}</div>\n   *   <div class=\"min-h-0 flex-1\">\n   *     <ng-container [ngTemplateOutlet]=\"childCanvas()\" />\n   *   </div>\n   * </div>\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   * Bật để GIỮ `x`/`y` truyền vào. Mặc định tắt: thư viện tự xếp khối xuống hàng trống kế tiếp.\n   *\n   * 🔴 Phải là cờ tường minh, KHÔNG suy ra từ việc có truyền `x`/`y` hay không: `0` vừa là toạ độ\n   * hợp lệ vừa là giá trị mọi hàm dựng node điền sẵn, nên đoán nhầm là khối mới đè lên khối cũ.\n   *\n   * Cờ này chỉ để điều khiển lúc thêm, không được lưu lại trong cây.\n   */\n  keepPosition?: boolean;\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  /**\n   * Số hàng TỐI THIỂU của lưới CẤP TRANG. Mặc định 2.\n   *\n   * Đặt lớn hơn khi muốn ô li phủ kín màn hình ngay cả lúc bố cục còn ít khối — lưới chỉ cao bằng\n   * khối cuối cùng thì phần dưới trống trơn, người dùng không biết còn thả được vào đâu.\n   */\n  minRows?: number;\n  /** Số hàng TỐI THIỂU của lưới bên TRONG container. Mặc định 1 */\n  nestedMinRows?: number;\n  /**\n   * Cho lưới LỒNG tự đo lại khi khung chứa nó đổi bề rộng. Mặc định BẬT.\n   *\n   * Tắt đi thì lúc kéo mép khối cha, thẻ con đứng im tới khi thả tay — chỉ tắt nếu nơi dùng tự lo\n   * việc đo lại.\n   */\n  autoResizeNestedGrids?: boolean;\n  /** khe giữa hai khối ở lưới CẤP TRANG, px. Mặc định 12 */\n  margin?: number;\n  /**\n   * Khe NHÌN THẤY giữa hai khối cấp trang, px — phần vỏ khối thụt vào nửa khe mỗi cạnh.\n   *\n   * 🔴 Khác `margin`: `margin` là khe của Ô LƯỚI nên đổi nó là đổi luôn bước kéo và phép tính va\n   * chạm. Muốn thẻ trông thưa ra mà bước kéo giữ nguyên thì dùng `visualGap` — ô lưới không đổi,\n   * chỉ phần nhìn thấy co lại. Không khai thì không áp gì (giữ đúng hành vi cũ).\n   *\n   * Chỉ áp cho khối CẤP GỐC; khối con trong container giữ nguyên để không tách rời các dòng của\n   * cùng một thẻ.\n   */\n  visualGap?: 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  /**\n   * Lề TRÊN của lưới cấp trang, px — chỗ trống phía trên hàng 0.\n   *\n   * 🔴 Khai số này thay vì lấy `padding` của khung bọc khi nơi dùng đã đẩy vùng cuộn vào trong\n   * `<gridster>`: khoảng trống đó phải nằm TRONG hệ toạ độ của gridster thì thư viện mới tính đúng\n   * (`gridsterRenderer.getMarginTop`) và kéo–thả mới không lệch. Đặt ở khung bọc thì mép trên của\n   * gridster cắt mất mọi thứ thò lên — thanh công cụ của khối ở hàng 0 treo ở `top: -22px` biến mất.\n   */\n  outerMarginTop?: 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  /** Bật tính năng thu phóng (zoom) canvas. Mặc định false */\n  enableZoom?: boolean;\n  /** Tỷ lệ thu phóng ban đầu. Mặc định 1 (100%) */\n  initialZoom?: number;\n  /** Giới hạn thu phóng tối thiểu. Mặc định 0.4 (40%) */\n  zoomMin?: number;\n  /** Giới hạn thu phóng tối đa. Mặc định 1.5 (150%) */\n  zoomMax?: number;\n  /** Bước nhảy mỗi lần tăng/giảm thu phóng. Mặc định 0.05 (5%) */\n  zoomStep?: number;\n  /** Chiều rộng chuẩn của canvas stage, px. Mặc định 1668 */\n  stageWidth?: number;\n  /** Chiều cao tối thiểu của canvas stage, px. Mặc định 937 */\n  stageMinHeight?: number;\n  /** Khóa lưu tỷ lệ thu phóng vào localStorage (vd 'ocb_bi_canvas_zoom') */\n  storageKey?: string;\n  /** Tự động vừa màn hình khi tải trang lần đầu nếu khung nhìn nhỏ hơn stage. Mặc định true */\n  autoFitOnLoad?: boolean;\n};\n\n/** Lựa chọn tỷ lệ thu phóng trên menu dropdown */\nexport type T_gridLayout_zoomPreset = {\n  /** Khoá i18n, KHÔNG phải chữ hiển thị — template dịch qua `translate` pipe. */\n  label: string;\n  value: 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\n/**\n * Bối cảnh truyền vào `templateToolbar` — template tự vẽ thanh công cụ thay bộ nút mặc định.\n *\n * ```html\n * <ng-template #toolbar let-node let-ctx=\"ctx\">\n *   <libs_ui-components-buttons-button\n *     [classIconLeft]=\"'libs-ui-icon-remove'\"\n *     (outClick)=\"ctx.remove()\" />\n * </ng-template>\n * ```\n */\nexport type T_gridLayout_toolbarContext = {\n  /** khối đang vẽ — dùng `let-node` trong template */\n  $implicit: T_gridLayout_node;\n  /** khối này là container (có ruột) hay khối đơn */\n  isContainer: boolean;\n  /** còn thêm được khối vào trong không (chưa chạm trần lồng cấp) */\n  canAddInside: boolean;\n  /** đổi được giữa khối đơn ↔ khối ghép không */\n  canToggleType: boolean;\n  /** gọi để thư viện phát `outRemoveNode` như khi bấm nút xoá mặc định */\n  remove: () => void;\n  /** gọi để thư viện phát `outAddBlockInside` */\n  addInside: () => void;\n  /** gọi để thư viện phát `outToggleType` */\n  toggleType: () => void;\n};\n\n/** Khung xem trước (ghost preview) khi kéo thẻ từ bên ngoài vào canvas */\nexport type T_gridLayout_dropGhost = {\n  col: number;\n  row: number;\n  cols: number;\n  rows: number;\n  pixelLeft: number;\n  pixelTop: number;\n  pixelWidth: number;\n  pixelHeight: number;\n  isInsideGroup: boolean;\n  targetParentId?: string;\n  groupTitle?: string;\n  cardTitle: string;\n  cardIconText?: string;\n  cardIconClass?: string;\n  hoveredGridster?: HTMLElement;\n};\n\n/** Sự kiện phát ra khi thả một thẻ mới từ bên ngoài vào canvas */\nexport type T_gridLayout_dropEvent = {\n  node: T_gridLayout_node;\n  parentId?: string;\n  col: number;\n  row: number;\n  cols: number;\n  rows: number;\n  rawEvent: DragEvent;\n  payload?: unknown;\n};\n\n/** Dữ liệu của thẻ kéo từ bên ngoài vào canvas */\nexport type T_gridLayout_externalDragPayload = {\n  kind?: string;\n  type?: string;\n  title?: string;\n  cols?: number;\n  rows?: number;\n  iconText?: string;\n  iconClass?: string;\n  data?: Record<string, unknown>;\n  /**\n   * Khối này có được thả VÀO TRONG một khối ghép không. Bỏ trống = được (giữ nguyên hành vi cũ).\n   *\n   * 🔴 Khai `false` cho thứ mà nơi dùng sẽ từ chối khi thả (vd chính khối ghép — lồng khối ghép vào\n   * khối ghép). Thiếu cờ này thì thư viện vẫn tô ô li lên khối ghép đang rê qua, mời người dùng thả\n   * vào chỗ mà nơi dùng chắc chắn chối — thả xong khối nhảy ra ngoài (người dùng chỉ ra 15/09/2026).\n   */\n  canDropInsideContainer?: boolean;\n  [key: string]: unknown;\n};\n\n"]}