@libs-ui/services-grid-layout 0.2.357-21 → 0.2.357-22

package/canvas/grid-layout-canvas.component.d.ts

@@ -152,6 +152,7 @@ export declare class LibsUiGridLayoutCanvasComponent implements AfterViewInit, O
         resetZoom: () => void;
         fitToScreen: () => void;
         setZoom: (val: number) => void;
+        scrollArea: () => HTMLElement | undefined;
     };
     protected handlerZoomIn(): void;
     protected handlerZoomOut(): void;

package/defines/collision.define.d.ts

@@ -1,4 +1,4 @@
-import { T_gridLayout_dropGhost, T_gridLayout_externalDragPayload, T_gridLayout_node } from '../interfaces/grid-layout.interface';
+import { T_gridLayout_dropGhost, T_gridLayout_externalDragPayload, T_gridLayout_newNode, T_gridLayout_node } from '../interfaces/grid-layout.interface';
 /**
  * Checks whether the rectangular region [x, x + cols) x [y, y + rows)
  * is completely vacant among existing items.
@@ -28,4 +28,29 @@ export declare const findHoveredGroup: (elements: Element[], canvasContainer: HT
  * Calculates snapped spatial coordinates and pixel dimensions for drop ghost preview box.
  */
 export declare const calculateDropGhost: (event: DragEvent, canvasContainer: HTMLElement, root: T_gridLayout_node, payload: T_gridLayout_externalDragPayload, totalCols?: number) => T_gridLayout_dropGhost | undefined;
+/** Tìm khối theo id trong cây, đi sâu vào mọi container. */
+export declare const findNodeRecursive: (root: T_gridLayout_node, id: string) => T_gridLayout_node | undefined;
+/** Tìm khối CHA trực tiếp của một khối, đi sâu vào mọi container. */
+export declare const findParentRecursive: (root: T_gridLayout_node, id: string) => T_gridLayout_node | undefined;
+/**
+ * Thả khối vào đúng ô mà ghost đang chỉ, đẩy các khối va chạm xuống dưới.
+ *
+ * Ghost đang nằm trong một container (`isInsideGroup`) thì thả vào ruột container đó; không tìm thấy
+ * container thì trả `false` chứ KHÔNG rơi về lưới gốc — thả nhầm cấp khó nhận ra hơn là không thả.
+ */
+export declare const dropNodeAtCoordinates: (root: T_gridLayout_node, ghost: T_gridLayout_dropGhost, newNode: T_gridLayout_newNode) => boolean;
+/** Khối có phải CONTAINER không — tức có khối con bên trong. */
+export declare const isContainerNode: (node: T_gridLayout_node) => boolean;
+/** Khối có nằm LỒNG bên trong một container không (không phải con trực tiếp của gốc). */
+export declare const isNodeNestedInside: (root: T_gridLayout_node | undefined, nodeId: string) => boolean;
+/**
+ * Có được đổi khối đơn ↔ container không.
+ *
+ * 🔴 Ba hàm cờ này PHẢI là nguồn duy nhất cho cả thanh công cụ của thư viện lẫn menu do nơi dùng tự
+ * dựng. Trước đây nơi dùng phải chép lại quy tắc để dựng menu trước lúc render, và hai bản lệch nhau
+ * mỗi khi thư viện đổi trần lồng cấp mà không có gì báo.
+ */
+export declare const canToggleTypeNode: (root: T_gridLayout_node | undefined, node: T_gridLayout_node) => boolean;
+/** Có được thêm khối vào BÊN TRONG khối này không. */
+export declare const canAddInsideNode: (root: T_gridLayout_node | undefined, node: T_gridLayout_node) => boolean;
 export {};

package/drag-controller.d.ts

@@ -0,0 +1,34 @@
+import { T_gridLayout_dropGhost, T_gridLayout_externalDragPayload, T_gridLayout_node } from './interfaces/grid-layout.interface';
+/**
+ * Giữ trạng thái một lượt kéo khối từ palette bên ngoài vào mặt phẳng.
+ *
+ * Việc nó lo: bật ô li của lưới đang được kéo tới (lưới gốc, và lưới của container khi con trỏ đi
+ * vào trong), tắt đúng lúc, và trả về ghost để nơi dùng vẽ khung xem trước.
+ *
+ * 🔴 Tự bật/tắt ô li bằng tay ở nơi dùng là chỗ rất dễ sót: kéo ra khỏi container rồi mà quên tắt
+ * thì ô li của nó nằm lại trên màn, kéo sang lưới khác lại chồng thêm một lớp nữa.
+ */
+export declare class LibsUiGridLayoutDragController {
+    private payload?;
+    private hoveredElement?;
+    private rootGridsterElement?;
+    /** Payload của khối đang được kéo; `undefined` khi không có lượt kéo nào. */
+    get ActivePayload(): T_gridLayout_externalDragPayload | undefined;
+    /** Gọi ở `dragstart` của thẻ trong palette. */
+    onDragStart(payload: T_gridLayout_externalDragPayload): void;
+    /** Gọi ở `dragend` — dọn sạch mọi ô li đang bật. */
+    onDragEnd(container?: HTMLElement): void;
+    /** Tắt ô li của container đang hover. */
+    cleanupHoveredGroup(): void;
+    /** Tắt ô li của lưới gốc, và quét sạch lớp còn sót trong khung chứa. */
+    cleanupRootGrid(container?: HTMLElement): void;
+    /** Tắt toàn bộ ô li đang bật. */
+    cleanupAll(container?: HTMLElement): void;
+    /**
+     * Gọi ở `dragover` của khung chứa mặt phẳng. Trả ghost để nơi dùng vẽ khung xem trước, đồng thời
+     * tự bật ô li của lưới đang được kéo tới.
+     */
+    onDragOver(event: DragEvent, container: HTMLElement | undefined, root: T_gridLayout_node | undefined, totalCols?: number): T_gridLayout_dropGhost | undefined;
+    /** Bật ô li của lưới CẤP TRANG trong suốt lượt kéo, tắt lưới cũ nếu khung chứa đã đổi. */
+    private showRootGrid;
+}

package/esm2022/canvas/grid-layout-canvas.component.mjs

@@ -246,6 +246,9 @@ export class LibsUiGridLayoutCanvasComponent {
                 this.service.FunctionsControl.setZoom(val, this.storageKey());
                 this.syncZoomOut();
             },
+            // Vùng cuộn của mặt phẳng — nơi dùng cần nó để tự cuộn tới một khối, hoặc đo toạ độ khi kéo.
+            // Không mở ở đây thì nơi dùng phải dò bằng tên lớp CSS nội bộ, và tên đó đổi lúc nào không hay.
+            scrollArea: () => this.scrollAreaRef()?.nativeElement,
         };
     }
     handlerZoomIn() {
@@ -566,4 +569,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: HostListener,
                 args: ['document:click', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-layout-canvas.component.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/canvas/grid-layout-canvas.component.ts","../../../../../../libs-ui/services/grid-layout/src/canvas/grid-layout-canvas.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  HostListener,\n  OnDestroy,\n  TemplateRef,\n  ViewContainerRef,\n  computed,\n  effect,\n  inject,\n  input,\n  model,\n  output,\n  signal,\n  viewChild,\n  viewChildren,\n} from '@angular/core';\nimport { NgTemplateOutlet } from '@angular/common';\nimport { LibsUiComponentsButtonsButtonComponent } from '@libs-ui/components-buttons-button';\nimport { GridsterComponent, GridsterModule } from 'gridster18';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { emptyRootNode } from '../defines/gridster-config.define';\nimport { LibsUiGridLayoutService } from '../grid-layout.service';\nimport {\n  T_gridLayout_actionEvent,\n  T_gridLayout_addEvent,\n  T_gridLayout_changeEvent,\n  T_gridLayout_dropEvent,\n  T_gridLayout_dropGhost,\n  T_gridLayout_externalDragPayload,\n  T_gridLayout_newNode,\n  T_gridLayout_node,\n  T_gridLayout_toolbarContext,\n  T_gridLayout_zoomPreset,\n} from '../interfaces/grid-layout.interface';\nimport { calculateDropGhost, parseDropPayload } from '../defines/collision.define';\n\n/**\n * Mặt phẳng kéo thả. Đệ quy: khối có `children` thì ruột nó lại là một mặt phẳng nữa.\n *\n * Nơi dùng KHÔNG dựng component này trực tiếp cho từng khối — chỉ đặt MỘT thẻ ở gốc và truyền\n * `nodeComponentType` qua `LibsUiGridLayoutService.init()`. Thư viện tự gắn component cho mọi khối.\n */\n@Component({\n  selector: 'libs_ui-services-grid_layout-canvas',\n  standalone: true,\n  imports: [GridsterModule, LibsUiComponentsButtonsButtonComponent, NgTemplateOutlet, TranslateModule],\n  templateUrl: './grid-layout-canvas.component.html',\n  styleUrl: './grid-layout-canvas.component.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class LibsUiGridLayoutCanvasComponent implements AfterViewInit, OnDestroy {\n  /**\n   * @internal Chỉ mặt phẳng LỒNG dùng — thư viện tự truyền khi vẽ ruột container.\n   *\n   * Nơi dùng KHÔNG truyền: mặt phẳng gốc đọc cây từ service (đã đưa vào qua `init()`), truyền thêm\n   * ở đây là khai hai lần cùng một thứ (người dùng chốt 28/08/2026).\n   */\n  readonly node = input<T_gridLayout_node>();\n  /** @internal Chỉ mặt phẳng LỒNG dùng — thư viện tự truyền. */\n  readonly depth = input<number>(0);\n\n  /**\n   * Ẩn hẳn thanh công cụ mặc định (thêm-vào-trong · gộp/tách · xoá) của MỌI khối.\n   *\n   * Dùng khi sản phẩm gom các hành động đó vào chỗ khác — vd một nút ⋮ nằm trong chính nội dung\n   * khối. Ẩn rồi thì `outRemoveNode` · `outAddBlockInside` · `outToggleType` không còn nguồn phát\n   * từ thư viện; nơi dùng tự gọi `removeBlock` · `addBlock` · `toggleType` của service.\n   */\n  readonly hiddenToolbar = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /**\n   * Template tự vẽ thanh công cụ, thay cho bộ nút mặc định.\n   *\n   * Nhận context `{ $implicit: node, isContainer, canAddInside, canToggleType }` để nơi dùng vẽ đúng\n   * nút cho từng khối, rồi gọi ngược qua `outRemoveNode` · `outAddBlockInside` · `outToggleType`\n   * bằng chính các hàm trong context. Truyền cả `hiddenToolbar` và `templateToolbar` thì\n   * `hiddenToolbar` thắng — không vẽ gì.\n   */\n  readonly templateToolbar = input<TemplateRef<T_gridLayout_toolbarContext> | undefined>(undefined);\n\n  /**\n   * Bố cục vừa đổi do NGƯỜI DÙNG kéo hoặc đổi kích thước khối.\n   *\n   * Nơi dùng tự gọi `addBlock` · `removeBlock` · `compact` thì KHÔNG bắn — họ vừa gọi thì đã biết,\n   * bắn ngược lại là thừa (người dùng chốt 28/08/2026).\n   */\n  readonly outChange = output<T_gridLayout_changeEvent>();\n  /**\n   * Người dùng bấm nút XOÁ trên một khối. Thư viện CHƯA xoá — gọi `event.confirm()` để xoá thật.\n   * Cần hỏi trước thì hỏi xong mới gọi; không cho phép thì đừng gọi.\n   */\n  readonly outRemoveNode = output<T_gridLayout_actionEvent>();\n  /**\n   * Người dùng bấm nút THÊM trên một container. Thư viện KHÔNG tự thêm — nó không biết bạn có\n   * những loại khối nào. Mở menu chọn loại rồi gọi `event.confirm(item)` với khối bạn muốn thêm.\n   */\n  readonly outAddBlockInside = output<T_gridLayout_addEvent>();\n  /** Người dùng bấm nút GỘP/TÁCH. Thư viện chưa làm gì — gọi `event.confirm()` để thực hiện. */\n  readonly outToggleType = output<T_gridLayout_actionEvent>();\n\n  /** Bật tính năng thu phóng (zoom) canvas. Chỉ áp dụng cho canvas gốc (depth 0). */\n  readonly enableZoom = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /** Tỷ lệ thu phóng hiện tại (hỗ trợ two-way binding [(zoom)]=\"myZoom\"). */\n  readonly zoom = model<number | undefined>(undefined);\n\n  /** Giới hạn thu phóng tối thiểu. Mặc định 0.4 (40%). */\n  readonly zoomMin = input<number>(0.4);\n\n  /** Giới hạn thu phóng tối đa. Mặc định 1.5 (150%). */\n  readonly zoomMax = input<number>(1.5);\n\n  /** Bước nhảy thu phóng mỗi lần bấm +/- hoặc lăn chuột. Mặc định 0.05 (5%). */\n  readonly zoomStep = input<number>(0.05);\n\n  /** Chiều rộng chuẩn của canvas stage tính bằng px. Mặc định 1668. */\n  readonly stageWidth = input<number>(1668);\n\n  /** Chiều cao tối thiểu của canvas stage tính bằng px. Mặc định 937. */\n  readonly stageMinHeight = input<number>(937);\n\n  /** Khóa lưu tỷ lệ thu phóng vào localStorage. Mặc định 'ocb_bi_canvas_zoom'. */\n  readonly storageKey = input<string | undefined>('ocb_bi_canvas_zoom');\n\n  /** Hiển thị thanh dock điều khiển thu phóng nổi ở góc dưới phải. Mặc định true. */\n  readonly showZoomDock = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Tự động vừa màn hình khi tải trang lần đầu nếu khung nhìn nhỏ hơn stageWidth. Mặc định true. */\n  readonly autoFitOnLoad = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Phát ra khi tỷ lệ thu phóng thay đổi. */\n  readonly outZoomChange = output<number>();\n\n  /** Bật tính năng kéo thả thẻ từ bên ngoài vào canvas (mặc định true) */\n  readonly enableExternalDrop = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Luôn hiển thị đường kẻ lưới 24 cột */\n  readonly showGridLines = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /** Mã id của khối đang được chọn */\n  readonly selectedNodeId = model<string | null | undefined>(undefined);\n\n  /** Phát ra khi thả một thẻ mới từ bên ngoài vào canvas */\n  readonly outDropNode = output<T_gridLayout_dropEvent>();\n\n  /** Phát ra khi người dùng click chọn một khối */\n  readonly outSelectNode = output<T_gridLayout_node>();\n\n  /** Phát ra khi người dùng bấm nút cấu hình trên thanh công cụ của khối */\n  readonly outConfigNode = output<T_gridLayout_actionEvent>();\n\n  private readonly gridsterRef = viewChild(GridsterComponent);\n  private readonly scrollAreaRef = viewChild<ElementRef<HTMLElement>>('scrollArea');\n  private readonly zoomDockRef = viewChild<ElementRef<HTMLElement>>('zoomDock');\n  /** mỗi ô một chỗ gắn riêng — cùng thứ tự với `children()` */\n  private readonly itemHosts = viewChildren('itemHost', { read: ViewContainerRef });\n\n  /** Khung xem trước vị trí thả thẻ từ bên ngoài (snapped ghost preview) */\n  protected readonly dropGhost = signal<T_gridLayout_dropGhost | undefined>(undefined);\n\n  private activeHoveredEl?: HTMLElement;\n  private rootGridsterEl?: HTMLElement;\n\n  /** Menu chọn preset thu phóng đang mở hay đóng */\n  protected readonly isMenuOpen = signal<boolean>(false);\n\n  /** Các mốc thu phóng định sẵn */\n  protected readonly zoomPresets: Array<T_gridLayout_zoomPreset> = [\n    { label: 'i18n_zoom_preset_overview', value: 0.5 },\n    { label: 'i18n_zoom_preset_small_laptop', value: 0.67 },\n    { label: 'i18n_zoom_preset_laptop_1080p', value: 0.75 },\n    { label: 'i18n_zoom_preset_screen_1080p', value: 0.85 },\n    { label: 'i18n_zoom_preset_standard', value: 0.9 },\n    { label: 'i18n_zoom_preset_original_size', value: 1 },\n    { label: 'i18n_zoom_preset_large_screen', value: 1.1 },\n    { label: 'i18n_zoom_preset_high_dpi_2k', value: 1.25 },\n  ];\n\n  /** Sáu chấm của tay cầm kéo — chỉ để `@for` dựng đủ 6 thẻ, giá trị không dùng tới. */\n  protected readonly dragBarDots = [0, 1, 2, 3, 4, 5];\n\n  private readonly service = inject(LibsUiGridLayoutService);\n\n  /** Chế độ thu phóng có đang hoạt động trên canvas này không (chỉ root canvas depth 0) */\n  protected readonly isZoomActive = computed(() => {\n    return this.depth() === 0 && (this.enableZoom() || this.service.FunctionsControl.isZoomEnabled());\n  });\n\n  protected readonly currentZoom = computed(() => this.service.Zoom());\n  protected readonly zoomPercent = computed(() => Math.round(this.currentZoom() * 100));\n\n  /**\n   * Node THẬT của mặt phẳng này.\n   *\n   * 🔴 Mặt phẳng GỐC (depth 0) đọc cây từ SERVICE, không dùng input.\n   * Nơi dùng thường sửa cây TẠI CHỖ (`treeService.compact(tree)`) rồi gọi `refresh()`, nên signal\n   * `root()` của họ giữ nguyên tham chiếu và input `node` không hề đổi — `@for` không dựng lại\n   * `gridster-item`, lưới đứng im dù dữ liệu đã khác (đo 28/08/2026: bấm \"Sắp gọn\" không tác dụng).\n   * `refresh()` của service thay tham chiếu cây, nên đọc từ đó mới thấy thay đổi.\n   *\n   * Mặt phẳng LỒNG vẫn dùng input: nó nhận node con từ mặt phẳng cha, vốn đã là object mới.\n   */\n  protected readonly currentNode = computed(() => {\n    this.service.Version();\n\n    if (this.depth() > 0) {\n      return this.node() ?? emptyRootNode();\n    }\n\n    return this.service.Root() ?? emptyRootNode();\n  });\n\n  protected readonly children = computed(() => this.currentNode().children ?? []);\n\n  /**\n   * Bối cảnh cho `templateToolbar`, dựng sẵn theo từng khối.\n   *\n   * Dựng ở `computed` chứ không gọi hàm trên template: gọi hàm trong template chạy lại mỗi vòng\n   * dò thay đổi (rule `fe-coding-convention-templates` mục 6).\n   */\n  protected readonly toolbarContexts = computed<Array<T_gridLayout_toolbarContext>>(() =>\n    this.children().map((item) => ({\n      $implicit: item,\n      isContainer: this.isContainer(item),\n      canAddInside: this.canAddInside(item),\n      canToggleType: this.canToggleType(item),\n      remove: () => this.outRemoveNode.emit({ nodeId: item.id, node: item, confirm: () => this.service.removeBlock(item.id) }),\n      addInside: () => this.emitAddInside(item),\n      toggleType: () => this.emitToggleType(item),\n    }))\n  );\n\n  protected readonly isNestedCanvas = computed(() => this.depth() > 0);\n\n  /** trần lồng container — khối đã chạm trần thì không cho chuyển thành container */\n  protected readonly maxContainerDepth = computed(() => this.service.FunctionsControl.maxContainerDepth());\n\n  /**\n   * Lề trong của container, px.\n   *\n   * 🔴 Đặt trên VỎ container, không đặt vào lưới con. Lưới con giữ nguyên `margin: 2` như cũ; lề\n   * này chỉ co ruột lại khỏi biên vỏ, nhờ đó tay cầm đổi kích thước của khối con luôn nằm trong tầm\n   * chuột (người dùng chốt 28/08/2026).\n   */\n  protected readonly containerPadding = computed(() => `${this.service.FunctionsControl.containerPadding()}px`);\n\n  /** Dải kéo chỉ hiện ở chế độ sửa — chế độ xem không kéo được nên hiện dải là gây nhầm. */\n  protected readonly isEditMode = computed(() => this.service.IsEditMode());\n\n  protected readonly gridOptions = computed(() => {\n    // Đọc `Version` để `init()` lại (đổi chế độ, bật/tắt chồng khối) sinh ra options MỚI —\n    // gridster chỉ áp dụng cấu hình khi tham chiếu `options` đổi.\n    this.service.Version();\n\n    return this.service.FunctionsControl.gridsterOptions(this.depth(), () => this.outChange.emit({ root: this.currentNode() }));\n  });\n\n  constructor() {\n    // Gắn component của nơi dùng vào từng ô, và gắn LẠI mỗi khi cây đổi.\n    // Dùng effect vì `itemHosts()` chỉ có giá trị sau khi Angular dựng xong @for.\n    effect(() => {\n      const hosts = this.itemHosts();\n      const items = this.children();\n\n      items.forEach((item, i) => {\n        const host = hosts[i];\n\n        if (!host) {\n          return;\n        }\n\n        // Khối có con là CONTAINER: ruột nó do mặt phẳng lồng vẽ, không gắn component nội dung.\n        if ((item.children?.length ?? 0) > 0) {\n          return;\n        }\n\n        this.service.FunctionsControl.attachNode(item, this.depth() + 1, host);\n      });\n    });\n\n    // Đồng bộ nếu model zoom bên ngoài thay đổi\n    effect(() => {\n      const z = this.zoom();\n      if (z !== undefined && Math.abs(z - this.service.Zoom()) > 0.001) {\n        this.service.FunctionsControl.setZoom(z, this.storageKey());\n      }\n    });\n  }\n\n  ngAfterViewInit(): void {\n    if (!this.isZoomActive() || !this.autoFitOnLoad()) {\n      return;\n    }\n\n    const key = this.storageKey();\n    let hasSaved = false;\n    if (key && typeof localStorage !== 'undefined') {\n      try {\n        hasSaved = Boolean(localStorage.getItem(key));\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n\n    if (!hasSaved) {\n      setTimeout(() => {\n        const scrollEl = this.scrollAreaRef()?.nativeElement;\n        if (scrollEl && scrollEl.clientWidth > 0 && scrollEl.clientWidth < this.stageWidth() + 64) {\n          this.handlerFitScreen();\n        }\n      }, 50);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanupDragGrid();\n    for (const item of this.children()) {\n      this.service.FunctionsControl.detachNode(item.id);\n    }\n  }\n\n  /** Vẽ lại lưới — gọi khi khung ngoài đổi kích thước hoặc cây vừa đổi diện rộng. */\n  get FunctionControl() {\n    return {\n      veLaiLuoi: () => this.gridsterRef()?.optionsChanged(),\n      zoomIn: () => this.handlerZoomIn(),\n      zoomOut: () => this.handlerZoomOut(),\n      resetZoom: () => this.handlerResetZoom(),\n      fitToScreen: () => this.handlerFitScreen(),\n      setZoom: (val: number) => {\n        this.service.FunctionsControl.setZoom(val, this.storageKey());\n        this.syncZoomOut();\n      },\n    };\n  }\n\n  protected handlerZoomIn(): void {\n    this.service.FunctionsControl.zoomIn(this.zoomStep(), this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerZoomOut(): void {\n    this.service.FunctionsControl.zoomOut(this.zoomStep(), this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerResetZoom(): void {\n    this.service.FunctionsControl.resetZoom(this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerFitScreen(): void {\n    this.isMenuOpen.set(false);\n    const scrollEl = this.scrollAreaRef()?.nativeElement;\n    const containerWidth = scrollEl?.clientWidth || (typeof window !== 'undefined' ? window.innerWidth - 300 : 1200);\n    this.service.FunctionsControl.fitToScreen(containerWidth, this.stageWidth(), 48, this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerToggleMenu(): void {\n    this.isMenuOpen.update((open) => !open);\n  }\n\n  protected handlerSelectPreset(value: number): void {\n    this.isMenuOpen.set(false);\n    this.service.FunctionsControl.setZoom(value, this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected isCurrentPreset(value: number): boolean {\n    return Math.abs(this.currentZoom() - value) < 0.01;\n  }\n\n  private syncZoomOut(): void {\n    const val = this.service.Zoom();\n    this.outZoomChange.emit(val);\n    if (this.zoom() !== val) {\n      this.zoom.set(val);\n    }\n  }\n\n  protected handlerWheel(event: WheelEvent): void {\n    if (!this.isZoomActive()) {\n      return;\n    }\n\n    if (event.ctrlKey || event.metaKey) {\n      event.preventDefault();\n      if (event.deltaY < 0) {\n        this.handlerZoomIn();\n      } else if (event.deltaY > 0) {\n        this.handlerZoomOut();\n      }\n    }\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  protected handlerDocumentKeyDown(event: KeyboardEvent): void {\n    if (!this.isZoomActive()) {\n      return;\n    }\n\n    if (event.ctrlKey || event.metaKey) {\n      if (event.key === '=' || event.key === '+') {\n        event.preventDefault();\n        this.handlerZoomIn();\n      } else if (event.key === '-' || event.key === '_') {\n        event.preventDefault();\n        this.handlerZoomOut();\n      } else if (event.key === '0') {\n        event.preventDefault();\n        this.handlerResetZoom();\n      }\n    }\n  }\n\n  @HostListener('document:click', ['$event'])\n  protected handlerDocumentClick(event: MouseEvent): void {\n    if (!this.isMenuOpen()) {\n      return;\n    }\n\n    const dockEl = this.zoomDockRef()?.nativeElement;\n    if (dockEl && !dockEl.contains(event.target as Node)) {\n      this.isMenuOpen.set(false);\n    }\n  }\n\n  protected handlerTrackNode(_index: number, item: T_gridLayout_node): string {\n    return item.id;\n  }\n\n  /**\n   * 🔴 Chặn `mousedown` nổi lên lưới CHA khi thao tác trong lưới con.\n   * Không chặn thì cả hai lưới cùng nhận một cú bấm: kéo khối con là nhấc luôn container.\n   */\n  /**\n   * Chặn `mousedown` của khối trong lưới LỒNG nổi lên lưới cha.\n   *\n   * Chỉ chặn ở lưới lồng: lưới cấp trang không có cha nào để chặn, và chặn ở đó sẽ nuốt luôn thao\n   * tác của chính nó.\n   */\n  /**\n   * 🔴 Ba handler dưới đây PHẢI `stopPropagation`.\n   * Nút nằm trong vùng mang `dragHandleClass`, không chặn thì cú bấm bị gridster hiểu là bắt đầu kéo\n   * và `delayStart: 160` nuốt luôn `click` — người dùng thấy như nút chết.\n   */\n  protected handlerRemove(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.outRemoveNode.emit({ nodeId: node.id, node, confirm: () => this.service.removeBlock(node.id) });\n  }\n\n  protected handlerAddInside(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.emitAddInside(node);\n  }\n\n  protected handlerToggleType(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.emitToggleType(node);\n  }\n\n  /**\n   * Chặn cú bấm trong thanh công cụ nổi lên gridster.\n   *\n   * Chỉ `stopPropagation`, KHÔNG `preventDefault`: nút bên trong template của nơi dùng vẫn cần\n   * hành vi mặc định của mình (mở dropdown, focus…).\n   */\n  protected handlerStopEvent(event: Event): void {\n    event.stopPropagation();\n  }\n\n  /** Phát `outAddBlockInside` — dùng chung cho nút mặc định và `templateToolbar`. */\n  private emitAddInside(node: T_gridLayout_node): void {\n    this.outAddBlockInside.emit({\n      nodeId: node.id,\n      node,\n      confirm: (item: T_gridLayout_newNode) => this.service.addBlock(item, node.id),\n    });\n  }\n\n  /** Phát `outToggleType` — dùng chung cho nút mặc định và `templateToolbar`. */\n  private emitToggleType(node: T_gridLayout_node): void {\n    this.outToggleType.emit({\n      nodeId: node.id,\n      node,\n      // Gộp hay tách suy ra từ chính khối: đang là container thì tách, không thì gộp.\n      confirm: () => (this.isContainer(node) ? this.service.toSingle(node.id) : this.service.toContainer(node.id)),\n    });\n  }\n\n  /** khối này có phải container không (có khối con) */\n  protected isContainer(item: T_gridLayout_node): boolean {\n    return (item.children?.length ?? 0) > 0;\n  }\n\n  /** container đã chạm trần lồng thì không cho thêm khối vào trong nữa */\n  protected canAddInside(item: T_gridLayout_node): boolean {\n    return this.isContainer(item) && this.depth() < this.maxContainerDepth();\n  }\n\n  /** khối đơn ở cấp chưa chạm trần mới được chuyển thành container */\n  protected canToggleType(item: T_gridLayout_node): boolean {\n    if (this.isContainer(item)) {\n      return true;\n    }\n\n    return this.depth() < this.maxContainerDepth();\n  }\n\n  protected handlerBlockParentDrag(event: Event): void {\n    if (!this.isNestedCanvas()) {\n      return;\n    }\n\n    event.stopPropagation();\n  }\n\n  protected handlerMouseDownTrongLuoi(event: Event): void {\n    if (this.depth() === 0) {\n      return;\n    }\n\n    event.stopPropagation();\n  }\n\n  protected handlerSelectNode(node: T_gridLayout_node, event?: MouseEvent): void {\n    if (event) {\n      const target = event.target as HTMLElement;\n      if (target.closest('.libs-ui-grid-layout-toolbar') || target.closest('button')) {\n        return;\n      }\n    }\n    this.selectedNodeId.set(node.id);\n    this.outSelectNode.emit(node);\n  }\n\n  protected handlerConfig(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    const actionEvent: T_gridLayout_actionEvent = {\n      nodeId: node.id,\n      node,\n      confirm: () => true,\n    };\n    this.outConfigNode.emit(actionEvent);\n  }\n\n  protected handlerDragOver(event: DragEvent): void {\n    if (!this.enableExternalDrop() || this.depth() > 0) {\n      return;\n    }\n    event.preventDefault();\n    if (event.dataTransfer) {\n      event.dataTransfer.dropEffect = 'copy';\n    }\n\n    const container = this.scrollAreaRef()?.nativeElement;\n    const root = this.service.Root();\n    const payload = parseDropPayload<T_gridLayout_externalDragPayload>(\n      this.service.getDragPayload() as T_gridLayout_externalDragPayload | undefined,\n      event.dataTransfer,\n    );\n\n    if (!container || !root || !payload) {\n      return;\n    }\n\n    const rootGridster = container.querySelector('gridster') as HTMLElement | null;\n    if (rootGridster) {\n      if (!rootGridster.classList.contains('display-grid')) {\n        rootGridster.classList.add('display-grid');\n      }\n      this.rootGridsterEl = rootGridster;\n    }\n\n    const ghost = calculateDropGhost(event, container, root, payload, this.service.totalColumns);\n\n    if (ghost?.isInsideGroup && ghost.hoveredGridster) {\n      if (this.activeHoveredEl !== ghost.hoveredGridster) {\n        this.cleanupHoveredGroup();\n        ghost.hoveredGridster.classList.add('display-grid');\n        this.activeHoveredEl = ghost.hoveredGridster;\n      }\n    } else {\n      this.cleanupHoveredGroup();\n    }\n\n    this.dropGhost.set(ghost);\n  }\n\n  protected handlerDragLeave(event: DragEvent): void {\n    if (this.depth() > 0) {\n      return;\n    }\n    if (event.relatedTarget) {\n      const container = this.scrollAreaRef()?.nativeElement;\n      if (container && container.contains(event.relatedTarget as Node)) {\n        return;\n      }\n    }\n    this.dropGhost.set(undefined);\n    this.cleanupDragGrid();\n  }\n\n  protected handlerDrop(event: DragEvent): void {\n    if (!this.enableExternalDrop() || this.depth() > 0) {\n      return;\n    }\n    event.preventDefault();\n    const ghost = this.dropGhost();\n    const payload = parseDropPayload<T_gridLayout_externalDragPayload>(\n      this.service.getDragPayload() as T_gridLayout_externalDragPayload | undefined,\n      event.dataTransfer,\n    );\n\n    this.dropGhost.set(undefined);\n    this.cleanupDragGrid();\n    this.service.clearDragPayload();\n\n    if (!ghost || !payload) {\n      return;\n    }\n\n    const targetParentId = ghost.isInsideGroup ? ghost.targetParentId : undefined;\n    const isInside = Boolean(targetParentId);\n\n    let itemToAdd: T_gridLayout_newNode;\n    const payloadAny = payload as Record<string, unknown>;\n    if (typeof payloadAny['resolveNode'] === 'function') {\n      const resolved = (payloadAny['resolveNode'] as (inside: boolean) => T_gridLayout_newNode | undefined)(isInside);\n      itemToAdd = resolved ?? {\n        cols: ghost.cols,\n        rows: ghost.rows,\n        data: payload.data ?? (payload.type ? { type: payload.type, title: payload.title } : undefined),\n      };\n    } else {\n      const newNodeData = payload.data ?? (payload.type ? { type: payload.type, title: payload.title } : undefined);\n      itemToAdd = {\n        cols: ghost.cols,\n        rows: ghost.rows,\n        data: newNodeData,\n      };\n    }\n\n    const addedNode = this.service.insertBlockWithCollision(\n      itemToAdd,\n      ghost.col,\n      ghost.row,\n      targetParentId,\n    );\n\n    if (addedNode) {\n      this.selectedNodeId.set(addedNode.id);\n      this.outDropNode.emit({\n        node: addedNode,\n        parentId: targetParentId,\n        col: ghost.col,\n        row: ghost.row,\n        cols: ghost.cols,\n        rows: ghost.rows,\n        rawEvent: event,\n        payload,\n      });\n      const root = this.service.Root();\n      if (root) {\n        this.outChange.emit({\n          root,\n          nodeId: addedNode.id,\n        });\n      }\n    }\n  }\n\n  private cleanupHoveredGroup(): void {\n    if (this.activeHoveredEl) {\n      this.activeHoveredEl.classList.remove('display-grid');\n      this.activeHoveredEl = undefined;\n    }\n  }\n\n  private cleanupDragGrid(): void {\n    this.cleanupHoveredGroup();\n    if (this.rootGridsterEl && !this.showGridLines()) {\n      this.rootGridsterEl.classList.remove('display-grid');\n      this.rootGridsterEl = undefined;\n    }\n    const container = this.scrollAreaRef()?.nativeElement;\n    if (container && !this.showGridLines()) {\n      container.querySelectorAll('gridster.display-grid').forEach((el) => {\n        el.classList.remove('display-grid');\n      });\n    }\n  }\n}\n","@if (isZoomActive()) {\n  <!-- Khu vực cuộn chứa canvas stage thu phóng -->\n  <div\n    #scrollArea\n    class=\"libs-ui-grid-layout-scroll-area relative h-full min-h-0 w-full min-w-0 overflow-auto p-6 flex justify-center items-start\"\n    (mousedown)=\"handlerMouseDownTrongLuoi($event)\"\n    (wheel)=\"handlerWheel($event)\"\n    (dragover)=\"handlerDragOver($event)\"\n    (dragleave)=\"handlerDragLeave($event)\"\n    (drop)=\"handlerDrop($event)\">\n    <div\n      #canvasStage\n      id=\"bi-canvas-stage\"\n      class=\"libs-ui-grid-layout-stage relative flex flex-col transition-[zoom] duration-150 origin-top shrink-0 bg-white/80 border border-slate-200/80 rounded-2xl shadow-sm p-4\"\n      [style.zoom]=\"currentZoom()\"\n      [style.width.px]=\"stageWidth()\"\n      [style.min-width.px]=\"stageWidth()\"\n      [style.min-height.px]=\"stageMinHeight()\">\n      <!-- Snapped Drop Ghost Preview -->\n      @if (dropGhost(); as ghost) {\n        <div\n          class=\"pointer-events-none absolute z-30 flex flex-col items-center justify-center overflow-hidden rounded-lg border-2 border-dashed border-blue-500 bg-blue-500/15 p-1 shadow-sm transition-all duration-75 ease-out backdrop-blur-[0.5px] select-none\"\n          [style.left.px]=\"ghost.pixelLeft\"\n          [style.top.px]=\"ghost.pixelTop\"\n          [style.width.px]=\"ghost.pixelWidth\"\n          [style.height.px]=\"ghost.pixelHeight\">\n          <div class=\"inline-flex max-w-[95%] items-center gap-1 truncate rounded-md bg-blue-600 px-2 py-0.5 text-[11px] font-semibold text-white shadow-xs\">\n            @if (ghost.cardIconClass) {\n              <i [class]=\"ghost.cardIconClass + ' text-xs'\"></i>\n            } @else if (ghost.cardIconText) {\n              <span class=\"text-[10px] font-bold\">{{ ghost.cardIconText }}</span>\n            } @else {\n              <span class=\"text-xs font-bold\">{{ ghost.isInsideGroup ? '↳' : '+' }}</span>\n            }\n            <span class=\"truncate\">{{ ghost.cardTitle }}</span>\n            <span class=\"text-[9px] font-mono opacity-75\">({{ ghost.cols }}c)</span>\n          </div>\n\n          @if (ghost.pixelHeight >= 80) {\n            <div class=\"mt-1 flex max-w-[95%] items-center gap-1.5 truncate rounded border border-blue-100 bg-white/95 px-2 py-0.5 text-[10px] font-medium text-blue-700 shadow-xs\">\n              @if (ghost.isInsideGroup) {\n                <span class=\"truncate font-bold text-blue-900\">↳ {{ ghost.groupTitle }}</span>\n                <span class=\"text-blue-300\">•</span>\n              }\n              <span>Cột {{ ghost.col + 1 }}-{{ ghost.col + ghost.cols }}</span>\n            </div>\n          }\n        </div>\n      }\n      <gridster class=\"h-full w-full\" [class.display-grid]=\"showGridLines()\" [options]=\"gridOptions()\">\n          @for (item of children(); track item.id; let itemIndex = $index) {\n    <!-- 🔴 Chặn `mousedown` tại ĐÂY cho lưới lồng — CẤM bỏ và CẤM chuyển sang chỗ khác.\n         `ignoreContentClass` một mình KHÔNG đủ: `delayStart: 160` làm MỖI lưới lên lịch\n         `dragStart` bằng `setTimeout` ngay tại `mousedown`, còn `stopPropagation` mà lib gọi bên\n         trong `dragStart` chạy sau 160ms nên quá muộn — lưới CHA đã kịp nhận (đo 28/08/2026: kéo\n         dải khối con, chuỗi class duyệt lên ĐÚNG mà container vẫn nhảy 0,0 → 0,1).\n         Gắn ở `gridster-item` là đúng biên: lưới con nghe trên chính phần tử này nên đã nhận xong,\n         lưới cha ở ngoài bị chặn. -->\n    <gridster-item\n      [item]=\"item\"\n      [class.libs-ui-grid-layout-selected]=\"selectedNodeId() === item.id\"\n      (click)=\"handlerSelectNode(item, $event)\"\n      (mousedown)=\"handlerBlockParentDrag($event)\">\n      <!-- 🔴 Vỏ này mang `dragHandleClass` — CẤM bỏ.\n           `ignoreContent: true` bắt gridster CHỈ cho kéo khi chỗ bấm nằm dưới một phần tử có\n           `dragHandleClass`. Không có vỏ này thì component của nơi dùng (thư viện không kiểm soát\n           được class của nó) sẽ không có tay cầm nào, và KHÔNG khối nào kéo được — đo 28/08/2026:\n           kéo 320px, toạ độ khối giữ nguyên x=3,y=0.\n           Tên class theo cấp: lưới trang và lưới lồng dùng hai tên KHÁC nhau, nếu không lưới cha\n           cũng nhận ra tay cầm của khối con và nhấc luôn container. -->\n      <!-- 🔴 Vỏ KHÔNG mang `dragHandleClass` — CẤM thêm lại.\n           Kéo chỉ được phép bắt đầu từ DẢI XANH (người dùng chốt 28/08/2026: \"phải hover vào vùng\n           màu xanh thì mới kéo thả được cho đồng nhất\"). Cho cả vỏ làm tay cầm thì bấm đâu cũng\n           kéo, và khối con nằm trong container sẽ nhấc luôn container vì lưới cha duyệt lên gặp\n           tay cầm của vỏ container trước.\n           Vỏ khối con vẫn giữ class CHẶN để lưới cha dừng đúng ở biên. -->\n      <div\n        class=\"libs-ui-grid-layout-block-shell group relative h-full w-full min-w-0\"\n        [class.libs-ui-grid-layout-block-parent-drag]=\"isNestedCanvas()\">\n        <!-- Dải kéo: hiện khi rê chuột vào khối, ba chấm là dấu hiệu kéo quen thuộc.\n             Người dùng cần một chỗ bám RÕ RÀNG thay vì đoán xem bấm đâu thì kéo được\n             (chốt 28/08/2026, theo đúng dải đang dùng ở màn Customer 360 của mobio-web). -->\n        @if (isEditMode()) {\n          <!-- 🔴 Dải PHẢI mang tay cầm ĐÚNG CẤP của nó. Dải nhận chuột (`pointer-events: auto`),\n               nên nếu không mang tay cầm thì `checkDragHandleClass` duyệt lên gặp tay cầm của\n               container và nhấc container thay vì khối con (đo 28/08/2026: kéo dải khối con,\n               container nhảy 0,0 → 0,1 còn khối con đứng im).\n               🔴 Dải CHỈ mang tay cầm, CẤM mang thêm class chặn: `checkDragHandleClass` xét hai\n               class đó trên CÙNG một node nên để chung là kéo hỏng (đo 28/08/2026: bấm dải khối\n               con kéo 140px, khối đứng im). Việc chặn lưới cha do VỎ KHỐI lo. -->\n          <div\n            class=\"libs-ui-grid-layout-drag-bar\"\n            [class.libs-ui-grid-layout-drag-bar-child]=\"isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle]=\"!isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle-child]=\"isNestedCanvas()\">\n            <span class=\"libs-ui-grid-layout-drag-bar-dots\">\n              @for (dot of dragBarDots; track dot) {\n                <span class=\"libs-ui-grid-layout-drag-bar-dot\"></span>\n              }\n            </span>\n          </div>\n        }\n\n        <!-- Khung chứa component của nơi dùng.\n             🔴 PHẢI có khung thật (không phải `ng-container` trống): nó lo hộ nơi dùng phần lấp đầy\n             ô và viền báo chế độ sửa. Không có khung thì mỗi component nội dung lại phải tự viết\n             `:host { width/height: 100% }` + viền đứt — đó là việc của thư viện, không phải của\n             người dùng (người dùng chốt 28/08/2026).\n             Mỗi khối một ViewContainerRef riêng nên component nằm đúng ô của nó. -->\n        <div\n          class=\"libs-ui-grid-layout-content-frame\"\n          [class.libs-ui-grid-layout-content-frame-edit]=\"isEditMode() && !isContainer(item)\"\n          [class.libs-ui-grid-layout-content-frame-empty]=\"isContainer(item)\">\n          <ng-container #itemHost />\n        </div>\n\n        <!-- Dấu hiệu CONTAINER: nhãn góc trên-phải + viền đứt bao ruột. Không có dấu hiệu thì\n             người dùng không biết khối nào chứa được khối khác (chốt 28/08/2026, theo đúng cách\n             màn Customer 360 của mobio-web đang làm). -->\n        @if (isEditMode() && isContainer(item)) {\n          <div class=\"libs-ui-grid-layout-container-label\">{{ 'i18n_container_block' | translate }}</div>\n          <div class=\"libs-ui-grid-layout-container-border\"></div>\n        }\n\n        <!-- Thanh công cụ: hiện khi rê chuột vào khối.\n             🔴 Dùng `libs_ui-components-buttons-button` — CẤM tự dựng thẻ `<button>`.\n             Component này đã có sẵn kiểu nút, cỡ nút và bong bóng chú thích theo đúng bộ giao diện\n             của sản phẩm; tự dựng là mỗi nơi một kiểu và mất luôn tooltip. -->\n        @if (isEditMode() && !hiddenToolbar()) {\n          @if (templateToolbar()) {\n            <!-- Nơi dùng tự vẽ thanh công cụ: nhận khối + các hàm phát event qua context.\n\n                 🔴 Khối bọc tự chặn `mousedown`/`click` nổi lên gridster. Thanh công cụ nằm trong\n                 vùng mang `dragHandleClass`; không chặn thì cú bấm bị hiểu là bắt đầu kéo và\n                 `delayStart: 160` nuốt luôn `click` — nút trong template ngoài bấm không ăn\n                 (đo 09/09/2026: bấm bằng `.click()` của DOM thì mở, bấm chuột thật thì không).\n                 Chặn ở ĐÂY để nơi dùng không phải biết bẫy này. -->\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              role=\"toolbar\"\n              tabindex=\"0\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\"\n              (mousedown)=\"handlerStopEvent($event)\"\n              (keydown)=\"handlerStopEvent($event)\"\n              (click)=\"handlerStopEvent($event)\">\n              <ng-container\n                *ngTemplateOutlet=\"templateToolbar()!; context: toolbarContexts()[itemIndex]\" />\n            </div>\n          } @else {\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\">\n              <span class=\"libs-ui-grid-layout-dim-badge\">\n                {{ item.rows }} hàng × {{ item.cols }} cột\n              </span>\n              @if (canAddInside(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"'libs-ui-icon-add'\"\n                  [popover]=\"{ config: { content: 'Thêm khối vào trong', zIndex: 1300 } }\"\n                  (outClick)=\"handlerAddInside($event, item)\" />\n              }\n              @if (canToggleType(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"isContainer(item) ? 'libs-ui-icon-split-cell' : 'libs-ui-icon-merge-cell'\"\n                  [popover]=\"{ config: { content: isContainer(item) ? 'Đưa về khối đơn' : 'Chuyển thành khối ghép', zIndex: 1300 } }\"\n                  (outClick)=\"handlerToggleType($event, item)\" />\n              }\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-setting'\"\n                [popover]=\"{ config: { content: 'Cấu hình thẻ', zIndex: 1300 } }\"\n                (outClick)=\"handlerConfig($event, item)\" />\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third-hover-danger'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-remove'\"\n                [popover]=\"{ config: { content: isContainer(item) ? 'Xoá cả khối ghép' : 'Xoá khối', zIndex: 1300 } }\"\n                (outClick)=\"handlerRemove($event, item)\" />\n            </div>\n          }\n        }\n\n        @if (item.children && item.children.length > 0) {\n          <!-- Khối có con → ruột nó lại là một mặt phẳng nữa. Đệ quy ở đây, nơi dùng không phải lo.\n               Lề đặt ở ĐÂY (vỏ container), không đặt vào lưới con — lưới con giữ nguyên khe 2px. -->\n          <libs_ui-services-grid_layout-canvas\n            class=\"block h-full w-full\"\n            [style.padding]=\"containerPadding()\"\n            [node]=\"item\"\n            [depth]=\"depth() + 1\"\n            [hiddenToolbar]=\"hiddenToolbar()\"\n            [templateToolbar]=\"templateToolbar()\"\n            [selectedNodeId]=\"selectedNodeId()\"\n            (outSelectNode)=\"outSelectNode.emit($event)\"\n            (outConfigNode)=\"outConfigNode.emit($event)\"\n            (outChange)=\"outChange.emit($event)\"\n            (outRemoveNode)=\"outRemoveNode.emit($event)\"\n            (outAddBlockInside)=\"outAddBlockInside.emit($event)\"\n            (outToggleType)=\"outToggleType.emit($event)\" />\n        }\n      </div>\n    </gridster-item>\n  }\n      </gridster>\n    </div>\n  </div>\n\n  <!-- Thanh dock điều khiển thu phóng nổi ở góc dưới phải -->\n  @if (showZoomDock()) {\n    <div\n      #zoomDock\n      id=\"canvas-zoom-dock\"\n      role=\"toolbar\"\n      tabindex=\"0\"\n      class=\"absolute bottom-4 right-6 z-30 flex items-center bg-white/95 backdrop-blur-md rounded-full shadow-lg border border-slate-300/80 p-1 space-x-1 select-none\"\n      (mousedown)=\"$event.stopPropagation()\"\n      (keydown)=\"$event.stopPropagation()\"\n      (click)=\"$event.stopPropagation()\">\n      <!-- Thu nhỏ (-) -->\n      <button\n        type=\"button\"\n        class=\"w-7 h-7 flex items-center justify-center rounded-full text-slate-600 hover:text-slate-900 hover:bg-slate-100 disabled:opacity-30 disabled:hover:bg-transparent transition-colors cursor-pointer\"\n        [disabled]=\"currentZoom() <= zoomMin()\"\n        [title]=\"'i18n_zoom_out' | translate\"\n        (click)=\"handlerZoomOut()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"/></svg>\n      </button>\n\n      <!-- Tỷ lệ % và menu preset -->\n      <div class=\"relative\">\n        <button\n          type=\"button\"\n          class=\"h-7 px-2 flex items-center gap-1 rounded-full text-xs font-semibold text-slate-700 hover:bg-slate-100 transition-colors cursor-pointer\"\n          [title]=\"'i18n_zoom_options' | translate\"\n          (click)=\"handlerToggleMenu()\">\n          <span>{{ zoomPercent() }}%</span>\n          <svg class=\"w-3 h-3 text-slate-400 transition-transform duration-150\" [class.rotate-180]=\"isMenuOpen()\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"6 9 12 15 18 9\"/></svg>\n        </button>\n\n        <!-- Menu dropdown các mốc thu phóng -->\n        @if (isMenuOpen()) {\n          <div class=\"absolute bottom-full mb-2 right-0 w-64 bg-white rounded-xl shadow-xl border border-slate-200 py-1.5 z-40 text-xs select-none\">\n            <div class=\"px-3 py-1 text-[11px] font-semibold text-slate-400 uppercase tracking-wider\">\n              {{ 'i18n_zoom_canvas_width' | translate: { width: stageWidth() } }}\n            </div>\n            <button\n              type=\"button\"\n              class=\"w-full px-3 py-2 text-left flex items-center justify-between hover:bg-slate-50 transition-colors cursor-pointer\"\n              (click)=\"handlerFitScreen()\">\n              <span class=\"flex items-center gap-2 text-slate-700 font-medium\">\n                <svg class=\"w-3.5 h-3.5 text-slate-500\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><polyline points=\"15 3 21 3 21 9\"/><polyline points=\"9 21 3 21 3 15\"/><line x1=\"21\" y1=\"3\" x2=\"14\" y2=\"10\"/><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"/></svg>\n                {{ 'i18n_zoom_fit_screen' | translate }}\n              </span>\n              <span class=\"text-[10px] bg-blue-50 text-blue-600 px-1.5 py-0.5 rounded font-medium\">{{ 'i18n_auto' | translate }}</span>\n            </button>\n            <div class=\"h-px bg-slate-100 my-1\"></div>\n            @for (preset of zoomPresets; track preset.value) {\n              <button\n                type=\"button\"\n                class=\"w-full px-3 py-1.5 text-left flex items-center justify-between hover:bg-slate-50 transition-colors cursor-pointer\"\n                [class.text-blue-600]=\"isCurrentPreset(preset.value)\"\n                [class.font-semibold]=\"isCurrentPreset(preset.value)\"\n                [class.bg-blue-50]=\"isCurrentPreset(preset.value)\"\n                (click)=\"handlerSelectPreset(preset.value)\">\n                <span class=\"text-slate-700\" [class.text-blue-600]=\"isCurrentPreset(preset.value)\">\n                  {{ preset.label | translate }}\n                </span>\n                @if (isCurrentPreset(preset.value)) {\n                  <svg class=\"w-3.5 h-3.5 text-blue-600\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"20 6 9 17 4 12\"/></svg>\n                }\n              </button>\n            }\n          </div>\n        }\n      </div>\n\n      <!-- Phóng to (+) -->\n      <button\n        type=\"button\"\n        class=\"w-7 h-7 flex items-center justify-center rounded-full text-slate-600 hover:text-slate-900 hover:bg-slate-100 disabled:opacity-30 disabled:hover:bg-transparent transition-colors cursor-pointer\"\n        [disabled]=\"currentZoom() >= zoomMax()\"\n        [title]=\"'i18n_zoom_in' | translate\"\n        (click)=\"handlerZoomIn()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"/><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"/></svg>\n      </button>\n\n      <!-- Phân cách -->\n      <div class=\"h-4 w-px bg-slate-200\"></div>\n\n      <!-- Nút Vừa màn hình nhanh -->\n      <button\n        type=\"button\"\n        class=\"h-7 px-2.5 flex items-center gap-1 rounded-full text-xs text-slate-600 hover:text-slate-900 hover:bg-slate-100 transition-colors cursor-pointer\"\n        [title]=\"'i18n_zoom_fit_screen_tooltip' | translate\"\n        (click)=\"handlerFitScreen()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><polyline points=\"15 3 21 3 21 9\"/><polyline points=\"9 21 3 21 3 15\"/><line x1=\"21\" y1=\"3\" x2=\"14\" y2=\"10\"/><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"/></svg>\n        <span class=\"font-medium\">{{ 'i18n_zoom_fit_screen' | translate }}</span>\n      </button>\n\n      <!-- Nút Đặt lại 100% (chỉ hiện khi khác 100%) -->\n      @if (zoomPercent() !== 100) {\n        <button\n          type=\"button\"\n          class=\"h-7 px-2 flex items-center gap-1 rounded-full text-xs font-semibold text-blue-600 hover:bg-blue-50 transition-colors cursor-pointer\"\n          [title]=\"'i18n_zoom_reset_tooltip' | translate: { width: stageWidth(), height: stageMinHeight() }\"\n          (click)=\"handlerResetZoom()\">\n          <svg class=\"w-3 h-3\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"1 4 1 10 7 10\"/><path d=\"M3.51 15a9 9 0 1 0 2.13-9.36L1 10\"/></svg>\n          <span>100%</span>\n        </button>\n      }\n    </div>\n  }\n} @else {\n  <!-- 🔴 `relative` là BẮT BUỘC, CẤM bỏ.\n       gridster đổi vị trí chuột thành ô lưới bằng `e.clientY + (el.scrollTop - el.offsetTop)` — công\n       thức đó chỉ đúng khi `offsetParent` của <gridster> CHÍNH LÀ khối cuộn này. Thiếu `relative` thì\n       `offsetParent` nhảy lên khối bao ngoài: `offsetTop` trả 16 trong khi lệch thật là 65 → gridster\n       tính ô sai 49px, ô chờ đặt hiện lệch khỏi con trỏ nên kéo thả không đổi được vị trí, và kéo mép\n       cũng tính sai điểm dừng. -->\n  <div\n    #scrollArea\n    class=\"libs-ui-grid-layout-scroll-area relative h-full min-h-0 w-full min-w-0\"\n    [class.overflow-y-auto]=\"!isNestedCanvas()\"\n    (mousedown)=\"handlerMouseDownTrongLuoi($event)\"\n    (dragover)=\"handlerDragOver($event)\"\n    (dragleave)=\"handlerDragLeave($event)\"\n    (drop)=\"handlerDrop($event)\">\n    <!-- Snapped Drop Ghost Preview -->\n    @if (dropGhost(); as ghost) {\n      <div\n        class=\"pointer-events-none absolute z-30 flex flex-col items-center justify-center overflow-hidden rounded-lg border-2 border-dashed border-blue-500 bg-blue-500/15 p-1 shadow-sm transition-all duration-75 ease-out backdrop-blur-[0.5px] select-none\"\n        [style.left.px]=\"ghost.pixelLeft\"\n        [style.top.px]=\"ghost.pixelTop\"\n        [style.width.px]=\"ghost.pixelWidth\"\n        [style.height.px]=\"ghost.pixelHeight\">\n        <div class=\"inline-flex max-w-[95%] items-center gap-1 truncate rounded-md bg-blue-600 px-2 py-0.5 text-[11px] font-semibold text-white shadow-xs\">\n          @if (ghost.cardIconClass) {\n            <i [class]=\"ghost.cardIconClass + ' text-xs'\"></i>\n          } @else if (ghost.cardIconText) {\n            <span class=\"text-[10px] font-bold\">{{ ghost.cardIconText }}</span>\n          } @else {\n            <span class=\"text-xs font-bold\">{{ ghost.isInsideGroup ? '↳' : '+' }}</span>\n          }\n          <span class=\"truncate\">{{ ghost.cardTitle }}</span>\n          <span class=\"text-[9px] font-mono opacity-75\">({{ ghost.cols }}c)</span>\n        </div>\n\n        @if (ghost.pixelHeight >= 80) {\n          <div class=\"mt-1 flex max-w-[95%] items-center gap-1.5 truncate rounded border border-blue-100 bg-white/95 px-2 py-0.5 text-[10px] font-medium text-blue-700 shadow-xs\">\n            @if (ghost.isInsideGroup) {\n              <span class=\"truncate font-bold text-blue-900\">↳ {{ ghost.groupTitle }}</span>\n              <span class=\"text-blue-300\">•</span>\n            }\n            <span>Cột {{ ghost.col + 1 }}-{{ ghost.col + ghost.cols }}</span>\n          </div>\n        }\n      </div>\n    }\n    <gridster class=\"h-full w-full\" [class.display-grid]=\"showGridLines()\" [options]=\"gridOptions()\">\n        @for (item of children(); track item.id; let itemIndex = $index) {\n    <!-- 🔴 Chặn `mousedown` tại ĐÂY cho lưới lồng — CẤM bỏ và CẤM chuyển sang chỗ khác.\n         `ignoreContentClass` một mình KHÔNG đủ: `delayStart: 160` làm MỖI lưới lên lịch\n         `dragStart` bằng `setTimeout` ngay tại `mousedown`, còn `stopPropagation` mà lib gọi bên\n         trong `dragStart` chạy sau 160ms nên quá muộn — lưới CHA đã kịp nhận (đo 28/08/2026: kéo\n         dải khối con, chuỗi class duyệt lên ĐÚNG mà container vẫn nhảy 0,0 → 0,1).\n         Gắn ở `gridster-item` là đúng biên: lưới con nghe trên chính phần tử này nên đã nhận xong,\n         lưới cha ở ngoài bị chặn. -->\n    <gridster-item\n      [item]=\"item\"\n      [class.libs-ui-grid-layout-selected]=\"selectedNodeId() === item.id\"\n      (click)=\"handlerSelectNode(item, $event)\"\n      (mousedown)=\"handlerBlockParentDrag($event)\">\n      <!-- 🔴 Vỏ này mang `dragHandleClass` — CẤM bỏ.\n           `ignoreContent: true` bắt gridster CHỈ cho kéo khi chỗ bấm nằm dưới một phần tử có\n           `dragHandleClass`. Không có vỏ này thì component của nơi dùng (thư viện không kiểm soát\n           được class của nó) sẽ không có tay cầm nào, và KHÔNG khối nào kéo được — đo 28/08/2026:\n           kéo 320px, toạ độ khối giữ nguyên x=3,y=0.\n           Tên class theo cấp: lưới trang và lưới lồng dùng hai tên KHÁC nhau, nếu không lưới cha\n           cũng nhận ra tay cầm của khối con và nhấc luôn container. -->\n      <!-- 🔴 Vỏ KHÔNG mang `dragHandleClass` — CẤM thêm lại.\n           Kéo chỉ được phép bắt đầu từ DẢI XANH (người dùng chốt 28/08/2026: \"phải hover vào vùng\n           màu xanh thì mới kéo thả được cho đồng nhất\"). Cho cả vỏ làm tay cầm thì bấm đâu cũng\n           kéo, và khối con nằm trong container sẽ nhấc luôn container vì lưới cha duyệt lên gặp\n           tay cầm của vỏ container trước.\n           Vỏ khối con vẫn giữ class CHẶN để lưới cha dừng đúng ở biên. -->\n      <div\n        class=\"libs-ui-grid-layout-block-shell group relative h-full w-full min-w-0\"\n        [class.libs-ui-grid-layout-block-parent-drag]=\"isNestedCanvas()\">\n        <!-- Dải kéo: hiện khi rê chuột vào khối, ba chấm là dấu hiệu kéo quen thuộc.\n             Người dùng cần một chỗ bám RÕ RÀNG thay vì đoán xem bấm đâu thì kéo được\n             (chốt 28/08/2026, theo đúng dải đang dùng ở màn Customer 360 của mobio-web). -->\n        @if (isEditMode()) {\n          <!-- 🔴 Dải PHẢI mang tay cầm ĐÚNG CẤP của nó. Dải nhận chuột (`pointer-events: auto`),\n               nên nếu không mang tay cầm thì `checkDragHandleClass` duyệt lên gặp tay cầm của\n               container và nhấc container thay vì khối con (đo 28/08/2026: kéo dải khối con,\n               container nhảy 0,0 → 0,1 còn khối con đứng im).\n               🔴 Dải CHỈ mang tay cầm, CẤM mang thêm class chặn: `checkDragHandleClass` xét hai\n               class đó trên CÙNG một node nên để chung là kéo hỏng (đo 28/08/2026: bấm dải khối\n               con kéo 140px, khối đứng im). Việc chặn lưới cha do VỎ KHỐI lo. -->\n          <div\n            class=\"libs-ui-grid-layout-drag-bar\"\n            [class.libs-ui-grid-layout-drag-bar-child]=\"isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle]=\"!isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle-child]=\"isNestedCanvas()\">\n            <span class=\"libs-ui-grid-layout-drag-bar-dots\">\n              @for (dot of dragBarDots; track dot) {\n                <span class=\"libs-ui-grid-layout-drag-bar-dot\"></span>\n              }\n            </span>\n          </div>\n        }\n\n        <!-- Khung chứa component của nơi dùng.\n             🔴 PHẢI có khung thật (không phải `ng-container` trống): nó lo hộ nơi dùng phần lấp đầy\n             ô và viền báo chế độ sửa. Không có khung thì mỗi component nội dung lại phải tự viết\n             `:host { width/height: 100% }` + viền đứt — đó là việc của thư viện, không phải của\n             người dùng (người dùng chốt 28/08/2026).\n             Mỗi khối một ViewContainerRef riêng nên component nằm đúng ô của nó. -->\n        <div\n          class=\"libs-ui-grid-layout-content-frame\"\n          [class.libs-ui-grid-layout-content-frame-edit]=\"isEditMode() && !isContainer(item)\"\n          [class.libs-ui-grid-layout-content-frame-empty]=\"isContainer(item)\">\n          <ng-container #itemHost />\n        </div>\n\n        <!-- Dấu hiệu CONTAINER: nhãn góc trên-phải + viền đứt bao ruột. Không có dấu hiệu thì\n             người dùng không biết khối nào chứa được khối khác (chốt 28/08/2026, theo đúng cách\n             màn Customer 360 của mobio-web đang làm). -->\n        @if (isEditMode() && isContainer(item)) {\n          <div class=\"libs-ui-grid-layout-container-label\">{{ 'i18n_container_block' | translate }}</div>\n          <div class=\"libs-ui-grid-layout-container-border\"></div>\n        }\n\n        <!-- Thanh công cụ: hiện khi rê chuột vào khối.\n             🔴 Dùng `libs_ui-components-buttons-button` — CẤM tự dựng thẻ `<button>`.\n             Component này đã có sẵn kiểu nút, cỡ nút và bong bóng chú thích theo đúng bộ giao diện\n             của sản phẩm; tự dựng là mỗi nơi một kiểu và mất luôn tooltip. -->\n        @if (isEditMode() && !hiddenToolbar()) {\n          @if (templateToolbar()) {\n            <!-- Nơi dùng tự vẽ thanh công cụ: nhận khối + các hàm phát event qua context.\n\n                 🔴 Khối bọc tự chặn `mousedown`/`click` nổi lên gridster. Thanh công cụ nằm trong\n                 vùng mang `dragHandleClass`; không chặn thì cú bấm bị hiểu là bắt đầu kéo và\n                 `delayStart: 160` nuốt luôn `click` — nút trong template ngoài bấm không ăn\n                 (đo 09/09/2026: bấm bằng `.click()` của DOM thì mở, bấm chuột thật thì không).\n                 Chặn ở ĐÂY để nơi dùng không phải biết bẫy này. -->\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              role=\"toolbar\"\n              tabindex=\"0\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\"\n              (mousedown)=\"handlerStopEvent($event)\"\n              (keydown)=\"handlerStopEvent($event)\"\n              (click)=\"handlerStopEvent($event)\">\n              <ng-container\n                *ngTemplateOutlet=\"templateToolbar()!; context: toolbarContexts()[itemIndex]\" />\n            </div>\n          } @else {\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\">\n              <span class=\"libs-ui-grid-layout-dim-badge\">\n                {{ item.rows }} hàng × {{ item.cols }} cột\n              </span>\n              @if (canAddInside(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"'libs-ui-icon-add'\"\n                  [popover]=\"{ config: { content: 'Thêm khối vào trong', zIndex: 1300 } }\"\n                  (outClick)=\"handlerAddInside($event, item)\" />\n              }\n              @if (canToggleType(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"isContainer(item) ? 'libs-ui-icon-split-cell' : 'libs-ui-icon-merge-cell'\"\n                  [popover]=\"{ config: { content: isContainer(item) ? 'Đưa về khối đơn' : 'Chuyển thành khối ghép', zIndex: 1300 } }\"\n                  (outClick)=\"handlerToggleType($event, item)\" />\n              }\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-setting'\"\n                [popover]=\"{ config: { content: 'Cấu hình thẻ', zIndex: 1300 } }\"\n                (outClick)=\"handlerConfig($event, item)\" />\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third-hover-danger'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-remove'\"\n                [popover]=\"{ config: { content: isContainer(item) ? 'Xoá cả khối ghép' : 'Xoá khối', zIndex: 1300 } }\"\n                (outClick)=\"handlerRemove($event, item)\" />\n            </div>\n          }\n        }\n\n        @if (item.children && item.children.length > 0) {\n          <!-- Khối có con → ruột nó lại là một mặt phẳng nữa. Đệ quy ở đây, nơi dùng không phải lo.\n               Lề đặt ở ĐÂY (vỏ container), không đặt vào lưới con — lưới con giữ nguyên khe 2px. -->\n          <libs_ui-services-grid_layout-canvas\n            class=\"block h-full w-full\"\n            [style.padding]=\"containerPadding()\"\n            [node]=\"item\"\n            [depth]=\"depth() + 1\"\n            [hiddenToolbar]=\"hiddenToolbar()\"\n            [templateToolbar]=\"templateToolbar()\"\n            [selectedNodeId]=\"selectedNodeId()\"\n            (outSelectNode)=\"outSelectNode.emit($event)\"\n            (outConfigNode)=\"outConfigNode.emit($event)\"\n            (outChange)=\"outChange.emit($event)\"\n            (outRemoveNode)=\"outRemoveNode.emit($event)\"\n            (outAddBlockInside)=\"outAddBlockInside.emit($event)\"\n            (outToggleType)=\"outToggleType.emit($event)\" />\n        }\n      </div>\n    </gridster-item>\n  }\n    </gridster>\n  </div>\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-layout-canvas.component.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/canvas/grid-layout-canvas.component.ts","../../../../../../libs-ui/services/grid-layout/src/canvas/grid-layout-canvas.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  HostListener,\n  OnDestroy,\n  TemplateRef,\n  ViewContainerRef,\n  computed,\n  effect,\n  inject,\n  input,\n  model,\n  output,\n  signal,\n  viewChild,\n  viewChildren,\n} from '@angular/core';\nimport { NgTemplateOutlet } from '@angular/common';\nimport { LibsUiComponentsButtonsButtonComponent } from '@libs-ui/components-buttons-button';\nimport { GridsterComponent, GridsterModule } from 'gridster18';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { emptyRootNode } from '../defines/gridster-config.define';\nimport { LibsUiGridLayoutService } from '../grid-layout.service';\nimport {\n  T_gridLayout_actionEvent,\n  T_gridLayout_addEvent,\n  T_gridLayout_changeEvent,\n  T_gridLayout_dropEvent,\n  T_gridLayout_dropGhost,\n  T_gridLayout_externalDragPayload,\n  T_gridLayout_newNode,\n  T_gridLayout_node,\n  T_gridLayout_toolbarContext,\n  T_gridLayout_zoomPreset,\n} from '../interfaces/grid-layout.interface';\nimport { calculateDropGhost, parseDropPayload } from '../defines/collision.define';\n\n/**\n * Mặt phẳng kéo thả. Đệ quy: khối có `children` thì ruột nó lại là một mặt phẳng nữa.\n *\n * Nơi dùng KHÔNG dựng component này trực tiếp cho từng khối — chỉ đặt MỘT thẻ ở gốc và truyền\n * `nodeComponentType` qua `LibsUiGridLayoutService.init()`. Thư viện tự gắn component cho mọi khối.\n */\n@Component({\n  selector: 'libs_ui-services-grid_layout-canvas',\n  standalone: true,\n  imports: [GridsterModule, LibsUiComponentsButtonsButtonComponent, NgTemplateOutlet, TranslateModule],\n  templateUrl: './grid-layout-canvas.component.html',\n  styleUrl: './grid-layout-canvas.component.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class LibsUiGridLayoutCanvasComponent implements AfterViewInit, OnDestroy {\n  /**\n   * @internal Chỉ mặt phẳng LỒNG dùng — thư viện tự truyền khi vẽ ruột container.\n   *\n   * Nơi dùng KHÔNG truyền: mặt phẳng gốc đọc cây từ service (đã đưa vào qua `init()`), truyền thêm\n   * ở đây là khai hai lần cùng một thứ (người dùng chốt 28/08/2026).\n   */\n  readonly node = input<T_gridLayout_node>();\n  /** @internal Chỉ mặt phẳng LỒNG dùng — thư viện tự truyền. */\n  readonly depth = input<number>(0);\n\n  /**\n   * Ẩn hẳn thanh công cụ mặc định (thêm-vào-trong · gộp/tách · xoá) của MỌI khối.\n   *\n   * Dùng khi sản phẩm gom các hành động đó vào chỗ khác — vd một nút ⋮ nằm trong chính nội dung\n   * khối. Ẩn rồi thì `outRemoveNode` · `outAddBlockInside` · `outToggleType` không còn nguồn phát\n   * từ thư viện; nơi dùng tự gọi `removeBlock` · `addBlock` · `toggleType` của service.\n   */\n  readonly hiddenToolbar = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /**\n   * Template tự vẽ thanh công cụ, thay cho bộ nút mặc định.\n   *\n   * Nhận context `{ $implicit: node, isContainer, canAddInside, canToggleType }` để nơi dùng vẽ đúng\n   * nút cho từng khối, rồi gọi ngược qua `outRemoveNode` · `outAddBlockInside` · `outToggleType`\n   * bằng chính các hàm trong context. Truyền cả `hiddenToolbar` và `templateToolbar` thì\n   * `hiddenToolbar` thắng — không vẽ gì.\n   */\n  readonly templateToolbar = input<TemplateRef<T_gridLayout_toolbarContext> | undefined>(undefined);\n\n  /**\n   * Bố cục vừa đổi do NGƯỜI DÙNG kéo hoặc đổi kích thước khối.\n   *\n   * Nơi dùng tự gọi `addBlock` · `removeBlock` · `compact` thì KHÔNG bắn — họ vừa gọi thì đã biết,\n   * bắn ngược lại là thừa (người dùng chốt 28/08/2026).\n   */\n  readonly outChange = output<T_gridLayout_changeEvent>();\n  /**\n   * Người dùng bấm nút XOÁ trên một khối. Thư viện CHƯA xoá — gọi `event.confirm()` để xoá thật.\n   * Cần hỏi trước thì hỏi xong mới gọi; không cho phép thì đừng gọi.\n   */\n  readonly outRemoveNode = output<T_gridLayout_actionEvent>();\n  /**\n   * Người dùng bấm nút THÊM trên một container. Thư viện KHÔNG tự thêm — nó không biết bạn có\n   * những loại khối nào. Mở menu chọn loại rồi gọi `event.confirm(item)` với khối bạn muốn thêm.\n   */\n  readonly outAddBlockInside = output<T_gridLayout_addEvent>();\n  /** Người dùng bấm nút GỘP/TÁCH. Thư viện chưa làm gì — gọi `event.confirm()` để thực hiện. */\n  readonly outToggleType = output<T_gridLayout_actionEvent>();\n\n  /** Bật tính năng thu phóng (zoom) canvas. Chỉ áp dụng cho canvas gốc (depth 0). */\n  readonly enableZoom = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /** Tỷ lệ thu phóng hiện tại (hỗ trợ two-way binding [(zoom)]=\"myZoom\"). */\n  readonly zoom = model<number | undefined>(undefined);\n\n  /** Giới hạn thu phóng tối thiểu. Mặc định 0.4 (40%). */\n  readonly zoomMin = input<number>(0.4);\n\n  /** Giới hạn thu phóng tối đa. Mặc định 1.5 (150%). */\n  readonly zoomMax = input<number>(1.5);\n\n  /** Bước nhảy thu phóng mỗi lần bấm +/- hoặc lăn chuột. Mặc định 0.05 (5%). */\n  readonly zoomStep = input<number>(0.05);\n\n  /** Chiều rộng chuẩn của canvas stage tính bằng px. Mặc định 1668. */\n  readonly stageWidth = input<number>(1668);\n\n  /** Chiều cao tối thiểu của canvas stage tính bằng px. Mặc định 937. */\n  readonly stageMinHeight = input<number>(937);\n\n  /** Khóa lưu tỷ lệ thu phóng vào localStorage. Mặc định 'ocb_bi_canvas_zoom'. */\n  readonly storageKey = input<string | undefined>('ocb_bi_canvas_zoom');\n\n  /** Hiển thị thanh dock điều khiển thu phóng nổi ở góc dưới phải. Mặc định true. */\n  readonly showZoomDock = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Tự động vừa màn hình khi tải trang lần đầu nếu khung nhìn nhỏ hơn stageWidth. Mặc định true. */\n  readonly autoFitOnLoad = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Phát ra khi tỷ lệ thu phóng thay đổi. */\n  readonly outZoomChange = output<number>();\n\n  /** Bật tính năng kéo thả thẻ từ bên ngoài vào canvas (mặc định true) */\n  readonly enableExternalDrop = input<boolean, boolean | undefined>(true, { transform: (value) => value ?? true });\n\n  /** Luôn hiển thị đường kẻ lưới 24 cột */\n  readonly showGridLines = input<boolean, boolean | undefined>(false, { transform: (value) => value ?? false });\n\n  /** Mã id của khối đang được chọn */\n  readonly selectedNodeId = model<string | null | undefined>(undefined);\n\n  /** Phát ra khi thả một thẻ mới từ bên ngoài vào canvas */\n  readonly outDropNode = output<T_gridLayout_dropEvent>();\n\n  /** Phát ra khi người dùng click chọn một khối */\n  readonly outSelectNode = output<T_gridLayout_node>();\n\n  /** Phát ra khi người dùng bấm nút cấu hình trên thanh công cụ của khối */\n  readonly outConfigNode = output<T_gridLayout_actionEvent>();\n\n  private readonly gridsterRef = viewChild(GridsterComponent);\n  private readonly scrollAreaRef = viewChild<ElementRef<HTMLElement>>('scrollArea');\n  private readonly zoomDockRef = viewChild<ElementRef<HTMLElement>>('zoomDock');\n  /** mỗi ô một chỗ gắn riêng — cùng thứ tự với `children()` */\n  private readonly itemHosts = viewChildren('itemHost', { read: ViewContainerRef });\n\n  /** Khung xem trước vị trí thả thẻ từ bên ngoài (snapped ghost preview) */\n  protected readonly dropGhost = signal<T_gridLayout_dropGhost | undefined>(undefined);\n\n  private activeHoveredEl?: HTMLElement;\n  private rootGridsterEl?: HTMLElement;\n\n  /** Menu chọn preset thu phóng đang mở hay đóng */\n  protected readonly isMenuOpen = signal<boolean>(false);\n\n  /** Các mốc thu phóng định sẵn */\n  protected readonly zoomPresets: Array<T_gridLayout_zoomPreset> = [\n    { label: 'i18n_zoom_preset_overview', value: 0.5 },\n    { label: 'i18n_zoom_preset_small_laptop', value: 0.67 },\n    { label: 'i18n_zoom_preset_laptop_1080p', value: 0.75 },\n    { label: 'i18n_zoom_preset_screen_1080p', value: 0.85 },\n    { label: 'i18n_zoom_preset_standard', value: 0.9 },\n    { label: 'i18n_zoom_preset_original_size', value: 1 },\n    { label: 'i18n_zoom_preset_large_screen', value: 1.1 },\n    { label: 'i18n_zoom_preset_high_dpi_2k', value: 1.25 },\n  ];\n\n  /** Sáu chấm của tay cầm kéo — chỉ để `@for` dựng đủ 6 thẻ, giá trị không dùng tới. */\n  protected readonly dragBarDots = [0, 1, 2, 3, 4, 5];\n\n  private readonly service = inject(LibsUiGridLayoutService);\n\n  /** Chế độ thu phóng có đang hoạt động trên canvas này không (chỉ root canvas depth 0) */\n  protected readonly isZoomActive = computed(() => {\n    return this.depth() === 0 && (this.enableZoom() || this.service.FunctionsControl.isZoomEnabled());\n  });\n\n  protected readonly currentZoom = computed(() => this.service.Zoom());\n  protected readonly zoomPercent = computed(() => Math.round(this.currentZoom() * 100));\n\n  /**\n   * Node THẬT của mặt phẳng này.\n   *\n   * 🔴 Mặt phẳng GỐC (depth 0) đọc cây từ SERVICE, không dùng input.\n   * Nơi dùng thường sửa cây TẠI CHỖ (`treeService.compact(tree)`) rồi gọi `refresh()`, nên signal\n   * `root()` của họ giữ nguyên tham chiếu và input `node` không hề đổi — `@for` không dựng lại\n   * `gridster-item`, lưới đứng im dù dữ liệu đã khác (đo 28/08/2026: bấm \"Sắp gọn\" không tác dụng).\n   * `refresh()` của service thay tham chiếu cây, nên đọc từ đó mới thấy thay đổi.\n   *\n   * Mặt phẳng LỒNG vẫn dùng input: nó nhận node con từ mặt phẳng cha, vốn đã là object mới.\n   */\n  protected readonly currentNode = computed(() => {\n    this.service.Version();\n\n    if (this.depth() > 0) {\n      return this.node() ?? emptyRootNode();\n    }\n\n    return this.service.Root() ?? emptyRootNode();\n  });\n\n  protected readonly children = computed(() => this.currentNode().children ?? []);\n\n  /**\n   * Bối cảnh cho `templateToolbar`, dựng sẵn theo từng khối.\n   *\n   * Dựng ở `computed` chứ không gọi hàm trên template: gọi hàm trong template chạy lại mỗi vòng\n   * dò thay đổi (rule `fe-coding-convention-templates` mục 6).\n   */\n  protected readonly toolbarContexts = computed<Array<T_gridLayout_toolbarContext>>(() =>\n    this.children().map((item) => ({\n      $implicit: item,\n      isContainer: this.isContainer(item),\n      canAddInside: this.canAddInside(item),\n      canToggleType: this.canToggleType(item),\n      remove: () => this.outRemoveNode.emit({ nodeId: item.id, node: item, confirm: () => this.service.removeBlock(item.id) }),\n      addInside: () => this.emitAddInside(item),\n      toggleType: () => this.emitToggleType(item),\n    }))\n  );\n\n  protected readonly isNestedCanvas = computed(() => this.depth() > 0);\n\n  /** trần lồng container — khối đã chạm trần thì không cho chuyển thành container */\n  protected readonly maxContainerDepth = computed(() => this.service.FunctionsControl.maxContainerDepth());\n\n  /**\n   * Lề trong của container, px.\n   *\n   * 🔴 Đặt trên VỎ container, không đặt vào lưới con. Lưới con giữ nguyên `margin: 2` như cũ; lề\n   * này chỉ co ruột lại khỏi biên vỏ, nhờ đó tay cầm đổi kích thước của khối con luôn nằm trong tầm\n   * chuột (người dùng chốt 28/08/2026).\n   */\n  protected readonly containerPadding = computed(() => `${this.service.FunctionsControl.containerPadding()}px`);\n\n  /** Dải kéo chỉ hiện ở chế độ sửa — chế độ xem không kéo được nên hiện dải là gây nhầm. */\n  protected readonly isEditMode = computed(() => this.service.IsEditMode());\n\n  protected readonly gridOptions = computed(() => {\n    // Đọc `Version` để `init()` lại (đổi chế độ, bật/tắt chồng khối) sinh ra options MỚI —\n    // gridster chỉ áp dụng cấu hình khi tham chiếu `options` đổi.\n    this.service.Version();\n\n    return this.service.FunctionsControl.gridsterOptions(this.depth(), () => this.outChange.emit({ root: this.currentNode() }));\n  });\n\n  constructor() {\n    // Gắn component của nơi dùng vào từng ô, và gắn LẠI mỗi khi cây đổi.\n    // Dùng effect vì `itemHosts()` chỉ có giá trị sau khi Angular dựng xong @for.\n    effect(() => {\n      const hosts = this.itemHosts();\n      const items = this.children();\n\n      items.forEach((item, i) => {\n        const host = hosts[i];\n\n        if (!host) {\n          return;\n        }\n\n        // Khối có con là CONTAINER: ruột nó do mặt phẳng lồng vẽ, không gắn component nội dung.\n        if ((item.children?.length ?? 0) > 0) {\n          return;\n        }\n\n        this.service.FunctionsControl.attachNode(item, this.depth() + 1, host);\n      });\n    });\n\n    // Đồng bộ nếu model zoom bên ngoài thay đổi\n    effect(() => {\n      const z = this.zoom();\n      if (z !== undefined && Math.abs(z - this.service.Zoom()) > 0.001) {\n        this.service.FunctionsControl.setZoom(z, this.storageKey());\n      }\n    });\n  }\n\n  ngAfterViewInit(): void {\n    if (!this.isZoomActive() || !this.autoFitOnLoad()) {\n      return;\n    }\n\n    const key = this.storageKey();\n    let hasSaved = false;\n    if (key && typeof localStorage !== 'undefined') {\n      try {\n        hasSaved = Boolean(localStorage.getItem(key));\n      } catch {\n        // ignore localStorage access error\n      }\n    }\n\n    if (!hasSaved) {\n      setTimeout(() => {\n        const scrollEl = this.scrollAreaRef()?.nativeElement;\n        if (scrollEl && scrollEl.clientWidth > 0 && scrollEl.clientWidth < this.stageWidth() + 64) {\n          this.handlerFitScreen();\n        }\n      }, 50);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanupDragGrid();\n    for (const item of this.children()) {\n      this.service.FunctionsControl.detachNode(item.id);\n    }\n  }\n\n  /** Vẽ lại lưới — gọi khi khung ngoài đổi kích thước hoặc cây vừa đổi diện rộng. */\n  get FunctionControl() {\n    return {\n      veLaiLuoi: () => this.gridsterRef()?.optionsChanged(),\n      zoomIn: () => this.handlerZoomIn(),\n      zoomOut: () => this.handlerZoomOut(),\n      resetZoom: () => this.handlerResetZoom(),\n      fitToScreen: () => this.handlerFitScreen(),\n      setZoom: (val: number) => {\n        this.service.FunctionsControl.setZoom(val, this.storageKey());\n        this.syncZoomOut();\n      },\n      // Vùng cuộn của mặt phẳng — nơi dùng cần nó để tự cuộn tới một khối, hoặc đo toạ độ khi kéo.\n      // Không mở ở đây thì nơi dùng phải dò bằng tên lớp CSS nội bộ, và tên đó đổi lúc nào không hay.\n      scrollArea: (): HTMLElement | undefined => this.scrollAreaRef()?.nativeElement,\n    };\n  }\n\n  protected handlerZoomIn(): void {\n    this.service.FunctionsControl.zoomIn(this.zoomStep(), this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerZoomOut(): void {\n    this.service.FunctionsControl.zoomOut(this.zoomStep(), this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerResetZoom(): void {\n    this.service.FunctionsControl.resetZoom(this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerFitScreen(): void {\n    this.isMenuOpen.set(false);\n    const scrollEl = this.scrollAreaRef()?.nativeElement;\n    const containerWidth = scrollEl?.clientWidth || (typeof window !== 'undefined' ? window.innerWidth - 300 : 1200);\n    this.service.FunctionsControl.fitToScreen(containerWidth, this.stageWidth(), 48, this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected handlerToggleMenu(): void {\n    this.isMenuOpen.update((open) => !open);\n  }\n\n  protected handlerSelectPreset(value: number): void {\n    this.isMenuOpen.set(false);\n    this.service.FunctionsControl.setZoom(value, this.storageKey());\n    this.syncZoomOut();\n  }\n\n  protected isCurrentPreset(value: number): boolean {\n    return Math.abs(this.currentZoom() - value) < 0.01;\n  }\n\n  private syncZoomOut(): void {\n    const val = this.service.Zoom();\n    this.outZoomChange.emit(val);\n    if (this.zoom() !== val) {\n      this.zoom.set(val);\n    }\n  }\n\n  protected handlerWheel(event: WheelEvent): void {\n    if (!this.isZoomActive()) {\n      return;\n    }\n\n    if (event.ctrlKey || event.metaKey) {\n      event.preventDefault();\n      if (event.deltaY < 0) {\n        this.handlerZoomIn();\n      } else if (event.deltaY > 0) {\n        this.handlerZoomOut();\n      }\n    }\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  protected handlerDocumentKeyDown(event: KeyboardEvent): void {\n    if (!this.isZoomActive()) {\n      return;\n    }\n\n    if (event.ctrlKey || event.metaKey) {\n      if (event.key === '=' || event.key === '+') {\n        event.preventDefault();\n        this.handlerZoomIn();\n      } else if (event.key === '-' || event.key === '_') {\n        event.preventDefault();\n        this.handlerZoomOut();\n      } else if (event.key === '0') {\n        event.preventDefault();\n        this.handlerResetZoom();\n      }\n    }\n  }\n\n  @HostListener('document:click', ['$event'])\n  protected handlerDocumentClick(event: MouseEvent): void {\n    if (!this.isMenuOpen()) {\n      return;\n    }\n\n    const dockEl = this.zoomDockRef()?.nativeElement;\n    if (dockEl && !dockEl.contains(event.target as Node)) {\n      this.isMenuOpen.set(false);\n    }\n  }\n\n  protected handlerTrackNode(_index: number, item: T_gridLayout_node): string {\n    return item.id;\n  }\n\n  /**\n   * 🔴 Chặn `mousedown` nổi lên lưới CHA khi thao tác trong lưới con.\n   * Không chặn thì cả hai lưới cùng nhận một cú bấm: kéo khối con là nhấc luôn container.\n   */\n  /**\n   * Chặn `mousedown` của khối trong lưới LỒNG nổi lên lưới cha.\n   *\n   * Chỉ chặn ở lưới lồng: lưới cấp trang không có cha nào để chặn, và chặn ở đó sẽ nuốt luôn thao\n   * tác của chính nó.\n   */\n  /**\n   * 🔴 Ba handler dưới đây PHẢI `stopPropagation`.\n   * Nút nằm trong vùng mang `dragHandleClass`, không chặn thì cú bấm bị gridster hiểu là bắt đầu kéo\n   * và `delayStart: 160` nuốt luôn `click` — người dùng thấy như nút chết.\n   */\n  protected handlerRemove(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.outRemoveNode.emit({ nodeId: node.id, node, confirm: () => this.service.removeBlock(node.id) });\n  }\n\n  protected handlerAddInside(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.emitAddInside(node);\n  }\n\n  protected handlerToggleType(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    event.preventDefault();\n    this.emitToggleType(node);\n  }\n\n  /**\n   * Chặn cú bấm trong thanh công cụ nổi lên gridster.\n   *\n   * Chỉ `stopPropagation`, KHÔNG `preventDefault`: nút bên trong template của nơi dùng vẫn cần\n   * hành vi mặc định của mình (mở dropdown, focus…).\n   */\n  protected handlerStopEvent(event: Event): void {\n    event.stopPropagation();\n  }\n\n  /** Phát `outAddBlockInside` — dùng chung cho nút mặc định và `templateToolbar`. */\n  private emitAddInside(node: T_gridLayout_node): void {\n    this.outAddBlockInside.emit({\n      nodeId: node.id,\n      node,\n      confirm: (item: T_gridLayout_newNode) => this.service.addBlock(item, node.id),\n    });\n  }\n\n  /** Phát `outToggleType` — dùng chung cho nút mặc định và `templateToolbar`. */\n  private emitToggleType(node: T_gridLayout_node): void {\n    this.outToggleType.emit({\n      nodeId: node.id,\n      node,\n      // Gộp hay tách suy ra từ chính khối: đang là container thì tách, không thì gộp.\n      confirm: () => (this.isContainer(node) ? this.service.toSingle(node.id) : this.service.toContainer(node.id)),\n    });\n  }\n\n  /** khối này có phải container không (có khối con) */\n  protected isContainer(item: T_gridLayout_node): boolean {\n    return (item.children?.length ?? 0) > 0;\n  }\n\n  /** container đã chạm trần lồng thì không cho thêm khối vào trong nữa */\n  protected canAddInside(item: T_gridLayout_node): boolean {\n    return this.isContainer(item) && this.depth() < this.maxContainerDepth();\n  }\n\n  /** khối đơn ở cấp chưa chạm trần mới được chuyển thành container */\n  protected canToggleType(item: T_gridLayout_node): boolean {\n    if (this.isContainer(item)) {\n      return true;\n    }\n\n    return this.depth() < this.maxContainerDepth();\n  }\n\n  protected handlerBlockParentDrag(event: Event): void {\n    if (!this.isNestedCanvas()) {\n      return;\n    }\n\n    event.stopPropagation();\n  }\n\n  protected handlerMouseDownTrongLuoi(event: Event): void {\n    if (this.depth() === 0) {\n      return;\n    }\n\n    event.stopPropagation();\n  }\n\n  protected handlerSelectNode(node: T_gridLayout_node, event?: MouseEvent): void {\n    if (event) {\n      const target = event.target as HTMLElement;\n      if (target.closest('.libs-ui-grid-layout-toolbar') || target.closest('button')) {\n        return;\n      }\n    }\n    this.selectedNodeId.set(node.id);\n    this.outSelectNode.emit(node);\n  }\n\n  protected handlerConfig(event: Event, node: T_gridLayout_node): void {\n    event.stopPropagation();\n    const actionEvent: T_gridLayout_actionEvent = {\n      nodeId: node.id,\n      node,\n      confirm: () => true,\n    };\n    this.outConfigNode.emit(actionEvent);\n  }\n\n  protected handlerDragOver(event: DragEvent): void {\n    if (!this.enableExternalDrop() || this.depth() > 0) {\n      return;\n    }\n    event.preventDefault();\n    if (event.dataTransfer) {\n      event.dataTransfer.dropEffect = 'copy';\n    }\n\n    const container = this.scrollAreaRef()?.nativeElement;\n    const root = this.service.Root();\n    const payload = parseDropPayload<T_gridLayout_externalDragPayload>(\n      this.service.getDragPayload() as T_gridLayout_externalDragPayload | undefined,\n      event.dataTransfer,\n    );\n\n    if (!container || !root || !payload) {\n      return;\n    }\n\n    const rootGridster = container.querySelector('gridster') as HTMLElement | null;\n    if (rootGridster) {\n      if (!rootGridster.classList.contains('display-grid')) {\n        rootGridster.classList.add('display-grid');\n      }\n      this.rootGridsterEl = rootGridster;\n    }\n\n    const ghost = calculateDropGhost(event, container, root, payload, this.service.totalColumns);\n\n    if (ghost?.isInsideGroup && ghost.hoveredGridster) {\n      if (this.activeHoveredEl !== ghost.hoveredGridster) {\n        this.cleanupHoveredGroup();\n        ghost.hoveredGridster.classList.add('display-grid');\n        this.activeHoveredEl = ghost.hoveredGridster;\n      }\n    } else {\n      this.cleanupHoveredGroup();\n    }\n\n    this.dropGhost.set(ghost);\n  }\n\n  protected handlerDragLeave(event: DragEvent): void {\n    if (this.depth() > 0) {\n      return;\n    }\n    if (event.relatedTarget) {\n      const container = this.scrollAreaRef()?.nativeElement;\n      if (container && container.contains(event.relatedTarget as Node)) {\n        return;\n      }\n    }\n    this.dropGhost.set(undefined);\n    this.cleanupDragGrid();\n  }\n\n  protected handlerDrop(event: DragEvent): void {\n    if (!this.enableExternalDrop() || this.depth() > 0) {\n      return;\n    }\n    event.preventDefault();\n    const ghost = this.dropGhost();\n    const payload = parseDropPayload<T_gridLayout_externalDragPayload>(\n      this.service.getDragPayload() as T_gridLayout_externalDragPayload | undefined,\n      event.dataTransfer,\n    );\n\n    this.dropGhost.set(undefined);\n    this.cleanupDragGrid();\n    this.service.clearDragPayload();\n\n    if (!ghost || !payload) {\n      return;\n    }\n\n    const targetParentId = ghost.isInsideGroup ? ghost.targetParentId : undefined;\n    const isInside = Boolean(targetParentId);\n\n    let itemToAdd: T_gridLayout_newNode;\n    const payloadAny = payload as Record<string, unknown>;\n    if (typeof payloadAny['resolveNode'] === 'function') {\n      const resolved = (payloadAny['resolveNode'] as (inside: boolean) => T_gridLayout_newNode | undefined)(isInside);\n      itemToAdd = resolved ?? {\n        cols: ghost.cols,\n        rows: ghost.rows,\n        data: payload.data ?? (payload.type ? { type: payload.type, title: payload.title } : undefined),\n      };\n    } else {\n      const newNodeData = payload.data ?? (payload.type ? { type: payload.type, title: payload.title } : undefined);\n      itemToAdd = {\n        cols: ghost.cols,\n        rows: ghost.rows,\n        data: newNodeData,\n      };\n    }\n\n    const addedNode = this.service.insertBlockWithCollision(\n      itemToAdd,\n      ghost.col,\n      ghost.row,\n      targetParentId,\n    );\n\n    if (addedNode) {\n      this.selectedNodeId.set(addedNode.id);\n      this.outDropNode.emit({\n        node: addedNode,\n        parentId: targetParentId,\n        col: ghost.col,\n        row: ghost.row,\n        cols: ghost.cols,\n        rows: ghost.rows,\n        rawEvent: event,\n        payload,\n      });\n      const root = this.service.Root();\n      if (root) {\n        this.outChange.emit({\n          root,\n          nodeId: addedNode.id,\n        });\n      }\n    }\n  }\n\n  private cleanupHoveredGroup(): void {\n    if (this.activeHoveredEl) {\n      this.activeHoveredEl.classList.remove('display-grid');\n      this.activeHoveredEl = undefined;\n    }\n  }\n\n  private cleanupDragGrid(): void {\n    this.cleanupHoveredGroup();\n    if (this.rootGridsterEl && !this.showGridLines()) {\n      this.rootGridsterEl.classList.remove('display-grid');\n      this.rootGridsterEl = undefined;\n    }\n    const container = this.scrollAreaRef()?.nativeElement;\n    if (container && !this.showGridLines()) {\n      container.querySelectorAll('gridster.display-grid').forEach((el) => {\n        el.classList.remove('display-grid');\n      });\n    }\n  }\n}\n","@if (isZoomActive()) {\n  <!-- Khu vực cuộn chứa canvas stage thu phóng -->\n  <div\n    #scrollArea\n    class=\"libs-ui-grid-layout-scroll-area relative h-full min-h-0 w-full min-w-0 overflow-auto p-6 flex justify-center items-start\"\n    (mousedown)=\"handlerMouseDownTrongLuoi($event)\"\n    (wheel)=\"handlerWheel($event)\"\n    (dragover)=\"handlerDragOver($event)\"\n    (dragleave)=\"handlerDragLeave($event)\"\n    (drop)=\"handlerDrop($event)\">\n    <div\n      #canvasStage\n      id=\"bi-canvas-stage\"\n      class=\"libs-ui-grid-layout-stage relative flex flex-col transition-[zoom] duration-150 origin-top shrink-0 bg-white/80 border border-slate-200/80 rounded-2xl shadow-sm p-4\"\n      [style.zoom]=\"currentZoom()\"\n      [style.width.px]=\"stageWidth()\"\n      [style.min-width.px]=\"stageWidth()\"\n      [style.min-height.px]=\"stageMinHeight()\">\n      <!-- Snapped Drop Ghost Preview -->\n      @if (dropGhost(); as ghost) {\n        <div\n          class=\"pointer-events-none absolute z-30 flex flex-col items-center justify-center overflow-hidden rounded-lg border-2 border-dashed border-blue-500 bg-blue-500/15 p-1 shadow-sm transition-all duration-75 ease-out backdrop-blur-[0.5px] select-none\"\n          [style.left.px]=\"ghost.pixelLeft\"\n          [style.top.px]=\"ghost.pixelTop\"\n          [style.width.px]=\"ghost.pixelWidth\"\n          [style.height.px]=\"ghost.pixelHeight\">\n          <div class=\"inline-flex max-w-[95%] items-center gap-1 truncate rounded-md bg-blue-600 px-2 py-0.5 text-[11px] font-semibold text-white shadow-xs\">\n            @if (ghost.cardIconClass) {\n              <i [class]=\"ghost.cardIconClass + ' text-xs'\"></i>\n            } @else if (ghost.cardIconText) {\n              <span class=\"text-[10px] font-bold\">{{ ghost.cardIconText }}</span>\n            } @else {\n              <span class=\"text-xs font-bold\">{{ ghost.isInsideGroup ? '↳' : '+' }}</span>\n            }\n            <span class=\"truncate\">{{ ghost.cardTitle }}</span>\n            <span class=\"text-[9px] font-mono opacity-75\">({{ ghost.cols }}c)</span>\n          </div>\n\n          @if (ghost.pixelHeight >= 80) {\n            <div class=\"mt-1 flex max-w-[95%] items-center gap-1.5 truncate rounded border border-blue-100 bg-white/95 px-2 py-0.5 text-[10px] font-medium text-blue-700 shadow-xs\">\n              @if (ghost.isInsideGroup) {\n                <span class=\"truncate font-bold text-blue-900\">↳ {{ ghost.groupTitle }}</span>\n                <span class=\"text-blue-300\">•</span>\n              }\n              <span>Cột {{ ghost.col + 1 }}-{{ ghost.col + ghost.cols }}</span>\n            </div>\n          }\n        </div>\n      }\n      <gridster class=\"h-full w-full\" [class.display-grid]=\"showGridLines()\" [options]=\"gridOptions()\">\n          @for (item of children(); track item.id; let itemIndex = $index) {\n    <!-- 🔴 Chặn `mousedown` tại ĐÂY cho lưới lồng — CẤM bỏ và CẤM chuyển sang chỗ khác.\n         `ignoreContentClass` một mình KHÔNG đủ: `delayStart: 160` làm MỖI lưới lên lịch\n         `dragStart` bằng `setTimeout` ngay tại `mousedown`, còn `stopPropagation` mà lib gọi bên\n         trong `dragStart` chạy sau 160ms nên quá muộn — lưới CHA đã kịp nhận (đo 28/08/2026: kéo\n         dải khối con, chuỗi class duyệt lên ĐÚNG mà container vẫn nhảy 0,0 → 0,1).\n         Gắn ở `gridster-item` là đúng biên: lưới con nghe trên chính phần tử này nên đã nhận xong,\n         lưới cha ở ngoài bị chặn. -->\n    <gridster-item\n      [item]=\"item\"\n      [class.libs-ui-grid-layout-selected]=\"selectedNodeId() === item.id\"\n      (click)=\"handlerSelectNode(item, $event)\"\n      (mousedown)=\"handlerBlockParentDrag($event)\">\n      <!-- 🔴 Vỏ này mang `dragHandleClass` — CẤM bỏ.\n           `ignoreContent: true` bắt gridster CHỈ cho kéo khi chỗ bấm nằm dưới một phần tử có\n           `dragHandleClass`. Không có vỏ này thì component của nơi dùng (thư viện không kiểm soát\n           được class của nó) sẽ không có tay cầm nào, và KHÔNG khối nào kéo được — đo 28/08/2026:\n           kéo 320px, toạ độ khối giữ nguyên x=3,y=0.\n           Tên class theo cấp: lưới trang và lưới lồng dùng hai tên KHÁC nhau, nếu không lưới cha\n           cũng nhận ra tay cầm của khối con và nhấc luôn container. -->\n      <!-- 🔴 Vỏ KHÔNG mang `dragHandleClass` — CẤM thêm lại.\n           Kéo chỉ được phép bắt đầu từ DẢI XANH (người dùng chốt 28/08/2026: \"phải hover vào vùng\n           màu xanh thì mới kéo thả được cho đồng nhất\"). Cho cả vỏ làm tay cầm thì bấm đâu cũng\n           kéo, và khối con nằm trong container sẽ nhấc luôn container vì lưới cha duyệt lên gặp\n           tay cầm của vỏ container trước.\n           Vỏ khối con vẫn giữ class CHẶN để lưới cha dừng đúng ở biên. -->\n      <div\n        class=\"libs-ui-grid-layout-block-shell group relative h-full w-full min-w-0\"\n        [class.libs-ui-grid-layout-block-parent-drag]=\"isNestedCanvas()\">\n        <!-- Dải kéo: hiện khi rê chuột vào khối, ba chấm là dấu hiệu kéo quen thuộc.\n             Người dùng cần một chỗ bám RÕ RÀNG thay vì đoán xem bấm đâu thì kéo được\n             (chốt 28/08/2026, theo đúng dải đang dùng ở màn Customer 360 của mobio-web). -->\n        @if (isEditMode()) {\n          <!-- 🔴 Dải PHẢI mang tay cầm ĐÚNG CẤP của nó. Dải nhận chuột (`pointer-events: auto`),\n               nên nếu không mang tay cầm thì `checkDragHandleClass` duyệt lên gặp tay cầm của\n               container và nhấc container thay vì khối con (đo 28/08/2026: kéo dải khối con,\n               container nhảy 0,0 → 0,1 còn khối con đứng im).\n               🔴 Dải CHỈ mang tay cầm, CẤM mang thêm class chặn: `checkDragHandleClass` xét hai\n               class đó trên CÙNG một node nên để chung là kéo hỏng (đo 28/08/2026: bấm dải khối\n               con kéo 140px, khối đứng im). Việc chặn lưới cha do VỎ KHỐI lo. -->\n          <div\n            class=\"libs-ui-grid-layout-drag-bar\"\n            [class.libs-ui-grid-layout-drag-bar-child]=\"isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle]=\"!isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle-child]=\"isNestedCanvas()\">\n            <span class=\"libs-ui-grid-layout-drag-bar-dots\">\n              @for (dot of dragBarDots; track dot) {\n                <span class=\"libs-ui-grid-layout-drag-bar-dot\"></span>\n              }\n            </span>\n          </div>\n        }\n\n        <!-- Khung chứa component của nơi dùng.\n             🔴 PHẢI có khung thật (không phải `ng-container` trống): nó lo hộ nơi dùng phần lấp đầy\n             ô và viền báo chế độ sửa. Không có khung thì mỗi component nội dung lại phải tự viết\n             `:host { width/height: 100% }` + viền đứt — đó là việc của thư viện, không phải của\n             người dùng (người dùng chốt 28/08/2026).\n             Mỗi khối một ViewContainerRef riêng nên component nằm đúng ô của nó. -->\n        <div\n          class=\"libs-ui-grid-layout-content-frame\"\n          [class.libs-ui-grid-layout-content-frame-edit]=\"isEditMode() && !isContainer(item)\"\n          [class.libs-ui-grid-layout-content-frame-empty]=\"isContainer(item)\">\n          <ng-container #itemHost />\n        </div>\n\n        <!-- Dấu hiệu CONTAINER: nhãn góc trên-phải + viền đứt bao ruột. Không có dấu hiệu thì\n             người dùng không biết khối nào chứa được khối khác (chốt 28/08/2026, theo đúng cách\n             màn Customer 360 của mobio-web đang làm). -->\n        @if (isEditMode() && isContainer(item)) {\n          <div class=\"libs-ui-grid-layout-container-label\">{{ 'i18n_container_block' | translate }}</div>\n          <div class=\"libs-ui-grid-layout-container-border\"></div>\n        }\n\n        <!-- Thanh công cụ: hiện khi rê chuột vào khối.\n             🔴 Dùng `libs_ui-components-buttons-button` — CẤM tự dựng thẻ `<button>`.\n             Component này đã có sẵn kiểu nút, cỡ nút và bong bóng chú thích theo đúng bộ giao diện\n             của sản phẩm; tự dựng là mỗi nơi một kiểu và mất luôn tooltip. -->\n        @if (isEditMode() && !hiddenToolbar()) {\n          @if (templateToolbar()) {\n            <!-- Nơi dùng tự vẽ thanh công cụ: nhận khối + các hàm phát event qua context.\n\n                 🔴 Khối bọc tự chặn `mousedown`/`click` nổi lên gridster. Thanh công cụ nằm trong\n                 vùng mang `dragHandleClass`; không chặn thì cú bấm bị hiểu là bắt đầu kéo và\n                 `delayStart: 160` nuốt luôn `click` — nút trong template ngoài bấm không ăn\n                 (đo 09/09/2026: bấm bằng `.click()` của DOM thì mở, bấm chuột thật thì không).\n                 Chặn ở ĐÂY để nơi dùng không phải biết bẫy này. -->\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              role=\"toolbar\"\n              tabindex=\"0\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\"\n              (mousedown)=\"handlerStopEvent($event)\"\n              (keydown)=\"handlerStopEvent($event)\"\n              (click)=\"handlerStopEvent($event)\">\n              <ng-container\n                *ngTemplateOutlet=\"templateToolbar()!; context: toolbarContexts()[itemIndex]\" />\n            </div>\n          } @else {\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\">\n              <span class=\"libs-ui-grid-layout-dim-badge\">\n                {{ item.rows }} hàng × {{ item.cols }} cột\n              </span>\n              @if (canAddInside(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"'libs-ui-icon-add'\"\n                  [popover]=\"{ config: { content: 'Thêm khối vào trong', zIndex: 1300 } }\"\n                  (outClick)=\"handlerAddInside($event, item)\" />\n              }\n              @if (canToggleType(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"isContainer(item) ? 'libs-ui-icon-split-cell' : 'libs-ui-icon-merge-cell'\"\n                  [popover]=\"{ config: { content: isContainer(item) ? 'Đưa về khối đơn' : 'Chuyển thành khối ghép', zIndex: 1300 } }\"\n                  (outClick)=\"handlerToggleType($event, item)\" />\n              }\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-setting'\"\n                [popover]=\"{ config: { content: 'Cấu hình thẻ', zIndex: 1300 } }\"\n                (outClick)=\"handlerConfig($event, item)\" />\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third-hover-danger'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-remove'\"\n                [popover]=\"{ config: { content: isContainer(item) ? 'Xoá cả khối ghép' : 'Xoá khối', zIndex: 1300 } }\"\n                (outClick)=\"handlerRemove($event, item)\" />\n            </div>\n          }\n        }\n\n        @if (item.children && item.children.length > 0) {\n          <!-- Khối có con → ruột nó lại là một mặt phẳng nữa. Đệ quy ở đây, nơi dùng không phải lo.\n               Lề đặt ở ĐÂY (vỏ container), không đặt vào lưới con — lưới con giữ nguyên khe 2px. -->\n          <libs_ui-services-grid_layout-canvas\n            class=\"block h-full w-full\"\n            [style.padding]=\"containerPadding()\"\n            [node]=\"item\"\n            [depth]=\"depth() + 1\"\n            [hiddenToolbar]=\"hiddenToolbar()\"\n            [templateToolbar]=\"templateToolbar()\"\n            [selectedNodeId]=\"selectedNodeId()\"\n            (outSelectNode)=\"outSelectNode.emit($event)\"\n            (outConfigNode)=\"outConfigNode.emit($event)\"\n            (outChange)=\"outChange.emit($event)\"\n            (outRemoveNode)=\"outRemoveNode.emit($event)\"\n            (outAddBlockInside)=\"outAddBlockInside.emit($event)\"\n            (outToggleType)=\"outToggleType.emit($event)\" />\n        }\n      </div>\n    </gridster-item>\n  }\n      </gridster>\n    </div>\n  </div>\n\n  <!-- Thanh dock điều khiển thu phóng nổi ở góc dưới phải -->\n  @if (showZoomDock()) {\n    <div\n      #zoomDock\n      id=\"canvas-zoom-dock\"\n      role=\"toolbar\"\n      tabindex=\"0\"\n      class=\"absolute bottom-4 right-6 z-30 flex items-center bg-white/95 backdrop-blur-md rounded-full shadow-lg border border-slate-300/80 p-1 space-x-1 select-none\"\n      (mousedown)=\"$event.stopPropagation()\"\n      (keydown)=\"$event.stopPropagation()\"\n      (click)=\"$event.stopPropagation()\">\n      <!-- Thu nhỏ (-) -->\n      <button\n        type=\"button\"\n        class=\"w-7 h-7 flex items-center justify-center rounded-full text-slate-600 hover:text-slate-900 hover:bg-slate-100 disabled:opacity-30 disabled:hover:bg-transparent transition-colors cursor-pointer\"\n        [disabled]=\"currentZoom() <= zoomMin()\"\n        [title]=\"'i18n_zoom_out' | translate\"\n        (click)=\"handlerZoomOut()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"/></svg>\n      </button>\n\n      <!-- Tỷ lệ % và menu preset -->\n      <div class=\"relative\">\n        <button\n          type=\"button\"\n          class=\"h-7 px-2 flex items-center gap-1 rounded-full text-xs font-semibold text-slate-700 hover:bg-slate-100 transition-colors cursor-pointer\"\n          [title]=\"'i18n_zoom_options' | translate\"\n          (click)=\"handlerToggleMenu()\">\n          <span>{{ zoomPercent() }}%</span>\n          <svg class=\"w-3 h-3 text-slate-400 transition-transform duration-150\" [class.rotate-180]=\"isMenuOpen()\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"6 9 12 15 18 9\"/></svg>\n        </button>\n\n        <!-- Menu dropdown các mốc thu phóng -->\n        @if (isMenuOpen()) {\n          <div class=\"absolute bottom-full mb-2 right-0 w-64 bg-white rounded-xl shadow-xl border border-slate-200 py-1.5 z-40 text-xs select-none\">\n            <div class=\"px-3 py-1 text-[11px] font-semibold text-slate-400 uppercase tracking-wider\">\n              {{ 'i18n_zoom_canvas_width' | translate: { width: stageWidth() } }}\n            </div>\n            <button\n              type=\"button\"\n              class=\"w-full px-3 py-2 text-left flex items-center justify-between hover:bg-slate-50 transition-colors cursor-pointer\"\n              (click)=\"handlerFitScreen()\">\n              <span class=\"flex items-center gap-2 text-slate-700 font-medium\">\n                <svg class=\"w-3.5 h-3.5 text-slate-500\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><polyline points=\"15 3 21 3 21 9\"/><polyline points=\"9 21 3 21 3 15\"/><line x1=\"21\" y1=\"3\" x2=\"14\" y2=\"10\"/><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"/></svg>\n                {{ 'i18n_zoom_fit_screen' | translate }}\n              </span>\n              <span class=\"text-[10px] bg-blue-50 text-blue-600 px-1.5 py-0.5 rounded font-medium\">{{ 'i18n_auto' | translate }}</span>\n            </button>\n            <div class=\"h-px bg-slate-100 my-1\"></div>\n            @for (preset of zoomPresets; track preset.value) {\n              <button\n                type=\"button\"\n                class=\"w-full px-3 py-1.5 text-left flex items-center justify-between hover:bg-slate-50 transition-colors cursor-pointer\"\n                [class.text-blue-600]=\"isCurrentPreset(preset.value)\"\n                [class.font-semibold]=\"isCurrentPreset(preset.value)\"\n                [class.bg-blue-50]=\"isCurrentPreset(preset.value)\"\n                (click)=\"handlerSelectPreset(preset.value)\">\n                <span class=\"text-slate-700\" [class.text-blue-600]=\"isCurrentPreset(preset.value)\">\n                  {{ preset.label | translate }}\n                </span>\n                @if (isCurrentPreset(preset.value)) {\n                  <svg class=\"w-3.5 h-3.5 text-blue-600\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"20 6 9 17 4 12\"/></svg>\n                }\n              </button>\n            }\n          </div>\n        }\n      </div>\n\n      <!-- Phóng to (+) -->\n      <button\n        type=\"button\"\n        class=\"w-7 h-7 flex items-center justify-center rounded-full text-slate-600 hover:text-slate-900 hover:bg-slate-100 disabled:opacity-30 disabled:hover:bg-transparent transition-colors cursor-pointer\"\n        [disabled]=\"currentZoom() >= zoomMax()\"\n        [title]=\"'i18n_zoom_in' | translate\"\n        (click)=\"handlerZoomIn()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"/><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"/></svg>\n      </button>\n\n      <!-- Phân cách -->\n      <div class=\"h-4 w-px bg-slate-200\"></div>\n\n      <!-- Nút Vừa màn hình nhanh -->\n      <button\n        type=\"button\"\n        class=\"h-7 px-2.5 flex items-center gap-1 rounded-full text-xs text-slate-600 hover:text-slate-900 hover:bg-slate-100 transition-colors cursor-pointer\"\n        [title]=\"'i18n_zoom_fit_screen_tooltip' | translate\"\n        (click)=\"handlerFitScreen()\">\n        <svg class=\"w-3.5 h-3.5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><polyline points=\"15 3 21 3 21 9\"/><polyline points=\"9 21 3 21 3 15\"/><line x1=\"21\" y1=\"3\" x2=\"14\" y2=\"10\"/><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"/></svg>\n        <span class=\"font-medium\">{{ 'i18n_zoom_fit_screen' | translate }}</span>\n      </button>\n\n      <!-- Nút Đặt lại 100% (chỉ hiện khi khác 100%) -->\n      @if (zoomPercent() !== 100) {\n        <button\n          type=\"button\"\n          class=\"h-7 px-2 flex items-center gap-1 rounded-full text-xs font-semibold text-blue-600 hover:bg-blue-50 transition-colors cursor-pointer\"\n          [title]=\"'i18n_zoom_reset_tooltip' | translate: { width: stageWidth(), height: stageMinHeight() }\"\n          (click)=\"handlerResetZoom()\">\n          <svg class=\"w-3 h-3\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"1 4 1 10 7 10\"/><path d=\"M3.51 15a9 9 0 1 0 2.13-9.36L1 10\"/></svg>\n          <span>100%</span>\n        </button>\n      }\n    </div>\n  }\n} @else {\n  <!-- 🔴 `relative` là BẮT BUỘC, CẤM bỏ.\n       gridster đổi vị trí chuột thành ô lưới bằng `e.clientY + (el.scrollTop - el.offsetTop)` — công\n       thức đó chỉ đúng khi `offsetParent` của <gridster> CHÍNH LÀ khối cuộn này. Thiếu `relative` thì\n       `offsetParent` nhảy lên khối bao ngoài: `offsetTop` trả 16 trong khi lệch thật là 65 → gridster\n       tính ô sai 49px, ô chờ đặt hiện lệch khỏi con trỏ nên kéo thả không đổi được vị trí, và kéo mép\n       cũng tính sai điểm dừng. -->\n  <div\n    #scrollArea\n    class=\"libs-ui-grid-layout-scroll-area relative h-full min-h-0 w-full min-w-0\"\n    [class.overflow-y-auto]=\"!isNestedCanvas()\"\n    (mousedown)=\"handlerMouseDownTrongLuoi($event)\"\n    (dragover)=\"handlerDragOver($event)\"\n    (dragleave)=\"handlerDragLeave($event)\"\n    (drop)=\"handlerDrop($event)\">\n    <!-- Snapped Drop Ghost Preview -->\n    @if (dropGhost(); as ghost) {\n      <div\n        class=\"pointer-events-none absolute z-30 flex flex-col items-center justify-center overflow-hidden rounded-lg border-2 border-dashed border-blue-500 bg-blue-500/15 p-1 shadow-sm transition-all duration-75 ease-out backdrop-blur-[0.5px] select-none\"\n        [style.left.px]=\"ghost.pixelLeft\"\n        [style.top.px]=\"ghost.pixelTop\"\n        [style.width.px]=\"ghost.pixelWidth\"\n        [style.height.px]=\"ghost.pixelHeight\">\n        <div class=\"inline-flex max-w-[95%] items-center gap-1 truncate rounded-md bg-blue-600 px-2 py-0.5 text-[11px] font-semibold text-white shadow-xs\">\n          @if (ghost.cardIconClass) {\n            <i [class]=\"ghost.cardIconClass + ' text-xs'\"></i>\n          } @else if (ghost.cardIconText) {\n            <span class=\"text-[10px] font-bold\">{{ ghost.cardIconText }}</span>\n          } @else {\n            <span class=\"text-xs font-bold\">{{ ghost.isInsideGroup ? '↳' : '+' }}</span>\n          }\n          <span class=\"truncate\">{{ ghost.cardTitle }}</span>\n          <span class=\"text-[9px] font-mono opacity-75\">({{ ghost.cols }}c)</span>\n        </div>\n\n        @if (ghost.pixelHeight >= 80) {\n          <div class=\"mt-1 flex max-w-[95%] items-center gap-1.5 truncate rounded border border-blue-100 bg-white/95 px-2 py-0.5 text-[10px] font-medium text-blue-700 shadow-xs\">\n            @if (ghost.isInsideGroup) {\n              <span class=\"truncate font-bold text-blue-900\">↳ {{ ghost.groupTitle }}</span>\n              <span class=\"text-blue-300\">•</span>\n            }\n            <span>Cột {{ ghost.col + 1 }}-{{ ghost.col + ghost.cols }}</span>\n          </div>\n        }\n      </div>\n    }\n    <gridster class=\"h-full w-full\" [class.display-grid]=\"showGridLines()\" [options]=\"gridOptions()\">\n        @for (item of children(); track item.id; let itemIndex = $index) {\n    <!-- 🔴 Chặn `mousedown` tại ĐÂY cho lưới lồng — CẤM bỏ và CẤM chuyển sang chỗ khác.\n         `ignoreContentClass` một mình KHÔNG đủ: `delayStart: 160` làm MỖI lưới lên lịch\n         `dragStart` bằng `setTimeout` ngay tại `mousedown`, còn `stopPropagation` mà lib gọi bên\n         trong `dragStart` chạy sau 160ms nên quá muộn — lưới CHA đã kịp nhận (đo 28/08/2026: kéo\n         dải khối con, chuỗi class duyệt lên ĐÚNG mà container vẫn nhảy 0,0 → 0,1).\n         Gắn ở `gridster-item` là đúng biên: lưới con nghe trên chính phần tử này nên đã nhận xong,\n         lưới cha ở ngoài bị chặn. -->\n    <gridster-item\n      [item]=\"item\"\n      [class.libs-ui-grid-layout-selected]=\"selectedNodeId() === item.id\"\n      (click)=\"handlerSelectNode(item, $event)\"\n      (mousedown)=\"handlerBlockParentDrag($event)\">\n      <!-- 🔴 Vỏ này mang `dragHandleClass` — CẤM bỏ.\n           `ignoreContent: true` bắt gridster CHỈ cho kéo khi chỗ bấm nằm dưới một phần tử có\n           `dragHandleClass`. Không có vỏ này thì component của nơi dùng (thư viện không kiểm soát\n           được class của nó) sẽ không có tay cầm nào, và KHÔNG khối nào kéo được — đo 28/08/2026:\n           kéo 320px, toạ độ khối giữ nguyên x=3,y=0.\n           Tên class theo cấp: lưới trang và lưới lồng dùng hai tên KHÁC nhau, nếu không lưới cha\n           cũng nhận ra tay cầm của khối con và nhấc luôn container. -->\n      <!-- 🔴 Vỏ KHÔNG mang `dragHandleClass` — CẤM thêm lại.\n           Kéo chỉ được phép bắt đầu từ DẢI XANH (người dùng chốt 28/08/2026: \"phải hover vào vùng\n           màu xanh thì mới kéo thả được cho đồng nhất\"). Cho cả vỏ làm tay cầm thì bấm đâu cũng\n           kéo, và khối con nằm trong container sẽ nhấc luôn container vì lưới cha duyệt lên gặp\n           tay cầm của vỏ container trước.\n           Vỏ khối con vẫn giữ class CHẶN để lưới cha dừng đúng ở biên. -->\n      <div\n        class=\"libs-ui-grid-layout-block-shell group relative h-full w-full min-w-0\"\n        [class.libs-ui-grid-layout-block-parent-drag]=\"isNestedCanvas()\">\n        <!-- Dải kéo: hiện khi rê chuột vào khối, ba chấm là dấu hiệu kéo quen thuộc.\n             Người dùng cần một chỗ bám RÕ RÀNG thay vì đoán xem bấm đâu thì kéo được\n             (chốt 28/08/2026, theo đúng dải đang dùng ở màn Customer 360 của mobio-web). -->\n        @if (isEditMode()) {\n          <!-- 🔴 Dải PHẢI mang tay cầm ĐÚNG CẤP của nó. Dải nhận chuột (`pointer-events: auto`),\n               nên nếu không mang tay cầm thì `checkDragHandleClass` duyệt lên gặp tay cầm của\n               container và nhấc container thay vì khối con (đo 28/08/2026: kéo dải khối con,\n               container nhảy 0,0 → 0,1 còn khối con đứng im).\n               🔴 Dải CHỈ mang tay cầm, CẤM mang thêm class chặn: `checkDragHandleClass` xét hai\n               class đó trên CÙNG một node nên để chung là kéo hỏng (đo 28/08/2026: bấm dải khối\n               con kéo 140px, khối đứng im). Việc chặn lưới cha do VỎ KHỐI lo. -->\n          <div\n            class=\"libs-ui-grid-layout-drag-bar\"\n            [class.libs-ui-grid-layout-drag-bar-child]=\"isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle]=\"!isNestedCanvas()\"\n            [class.libs-ui-grid-layout-drag-handle-child]=\"isNestedCanvas()\">\n            <span class=\"libs-ui-grid-layout-drag-bar-dots\">\n              @for (dot of dragBarDots; track dot) {\n                <span class=\"libs-ui-grid-layout-drag-bar-dot\"></span>\n              }\n            </span>\n          </div>\n        }\n\n        <!-- Khung chứa component của nơi dùng.\n             🔴 PHẢI có khung thật (không phải `ng-container` trống): nó lo hộ nơi dùng phần lấp đầy\n             ô và viền báo chế độ sửa. Không có khung thì mỗi component nội dung lại phải tự viết\n             `:host { width/height: 100% }` + viền đứt — đó là việc của thư viện, không phải của\n             người dùng (người dùng chốt 28/08/2026).\n             Mỗi khối một ViewContainerRef riêng nên component nằm đúng ô của nó. -->\n        <div\n          class=\"libs-ui-grid-layout-content-frame\"\n          [class.libs-ui-grid-layout-content-frame-edit]=\"isEditMode() && !isContainer(item)\"\n          [class.libs-ui-grid-layout-content-frame-empty]=\"isContainer(item)\">\n          <ng-container #itemHost />\n        </div>\n\n        <!-- Dấu hiệu CONTAINER: nhãn góc trên-phải + viền đứt bao ruột. Không có dấu hiệu thì\n             người dùng không biết khối nào chứa được khối khác (chốt 28/08/2026, theo đúng cách\n             màn Customer 360 của mobio-web đang làm). -->\n        @if (isEditMode() && isContainer(item)) {\n          <div class=\"libs-ui-grid-layout-container-label\">{{ 'i18n_container_block' | translate }}</div>\n          <div class=\"libs-ui-grid-layout-container-border\"></div>\n        }\n\n        <!-- Thanh công cụ: hiện khi rê chuột vào khối.\n             🔴 Dùng `libs_ui-components-buttons-button` — CẤM tự dựng thẻ `<button>`.\n             Component này đã có sẵn kiểu nút, cỡ nút và bong bóng chú thích theo đúng bộ giao diện\n             của sản phẩm; tự dựng là mỗi nơi một kiểu và mất luôn tooltip. -->\n        @if (isEditMode() && !hiddenToolbar()) {\n          @if (templateToolbar()) {\n            <!-- Nơi dùng tự vẽ thanh công cụ: nhận khối + các hàm phát event qua context.\n\n                 🔴 Khối bọc tự chặn `mousedown`/`click` nổi lên gridster. Thanh công cụ nằm trong\n                 vùng mang `dragHandleClass`; không chặn thì cú bấm bị hiểu là bắt đầu kéo và\n                 `delayStart: 160` nuốt luôn `click` — nút trong template ngoài bấm không ăn\n                 (đo 09/09/2026: bấm bằng `.click()` của DOM thì mở, bấm chuột thật thì không).\n                 Chặn ở ĐÂY để nơi dùng không phải biết bẫy này. -->\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              role=\"toolbar\"\n              tabindex=\"0\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\"\n              (mousedown)=\"handlerStopEvent($event)\"\n              (keydown)=\"handlerStopEvent($event)\"\n              (click)=\"handlerStopEvent($event)\">\n              <ng-container\n                *ngTemplateOutlet=\"templateToolbar()!; context: toolbarContexts()[itemIndex]\" />\n            </div>\n          } @else {\n            <div\n              class=\"libs-ui-grid-layout-toolbar\"\n              [class.libs-ui-grid-layout-toolbar-child]=\"isNestedCanvas()\">\n              <span class=\"libs-ui-grid-layout-dim-badge\">\n                {{ item.rows }} hàng × {{ item.cols }} cột\n              </span>\n              @if (canAddInside(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"'libs-ui-icon-add'\"\n                  [popover]=\"{ config: { content: 'Thêm khối vào trong', zIndex: 1300 } }\"\n                  (outClick)=\"handlerAddInside($event, item)\" />\n              }\n              @if (canToggleType(item)) {\n                <libs_ui-components-buttons-button\n                  [type]=\"'button-third'\"\n                  [iconOnlyType]=\"true\"\n                  [sizeButton]=\"'smaller'\"\n                  [classIconLeft]=\"isContainer(item) ? 'libs-ui-icon-split-cell' : 'libs-ui-icon-merge-cell'\"\n                  [popover]=\"{ config: { content: isContainer(item) ? 'Đưa về khối đơn' : 'Chuyển thành khối ghép', zIndex: 1300 } }\"\n                  (outClick)=\"handlerToggleType($event, item)\" />\n              }\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-setting'\"\n                [popover]=\"{ config: { content: 'Cấu hình thẻ', zIndex: 1300 } }\"\n                (outClick)=\"handlerConfig($event, item)\" />\n              <libs_ui-components-buttons-button\n                [type]=\"'button-third-hover-danger'\"\n                [iconOnlyType]=\"true\"\n                [sizeButton]=\"'smaller'\"\n                [classIconLeft]=\"'libs-ui-icon-remove'\"\n                [popover]=\"{ config: { content: isContainer(item) ? 'Xoá cả khối ghép' : 'Xoá khối', zIndex: 1300 } }\"\n                (outClick)=\"handlerRemove($event, item)\" />\n            </div>\n          }\n        }\n\n        @if (item.children && item.children.length > 0) {\n          <!-- Khối có con → ruột nó lại là một mặt phẳng nữa. Đệ quy ở đây, nơi dùng không phải lo.\n               Lề đặt ở ĐÂY (vỏ container), không đặt vào lưới con — lưới con giữ nguyên khe 2px. -->\n          <libs_ui-services-grid_layout-canvas\n            class=\"block h-full w-full\"\n            [style.padding]=\"containerPadding()\"\n            [node]=\"item\"\n            [depth]=\"depth() + 1\"\n            [hiddenToolbar]=\"hiddenToolbar()\"\n            [templateToolbar]=\"templateToolbar()\"\n            [selectedNodeId]=\"selectedNodeId()\"\n            (outSelectNode)=\"outSelectNode.emit($event)\"\n            (outConfigNode)=\"outConfigNode.emit($event)\"\n            (outChange)=\"outChange.emit($event)\"\n            (outRemoveNode)=\"outRemoveNode.emit($event)\"\n            (outAddBlockInside)=\"outAddBlockInside.emit($event)\"\n            (outToggleType)=\"outToggleType.emit($event)\" />\n        }\n      </div>\n    </gridster-item>\n  }\n    </gridster>\n  </div>\n}\n"]}