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

package/esm2022/defines/collision.define.mjs

@@ -0,0 +1,329 @@
+import { uuid } from '@libs-ui/utils';
+/**
+ * Checks whether the rectangular region [x, x + cols) x [y, y + rows)
+ * is completely vacant among existing items.
+ */
+export const isRegionFree = (children, x, y, cols, rows, ignoredId) => {
+    for (const child of children) {
+        if (ignoredId && child.id === ignoredId) {
+            continue;
+        }
+        const hOverlap = !(child.x + child.cols <= x || child.x >= x + cols);
+        const vOverlap = !(child.y + child.rows <= y || child.y >= y + rows);
+        if (hOverlap && vOverlap) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Computes optimal (col, row) inside a group container.
+ * Snaps flush to adjacent card right edge if slot is vacant.
+ */
+export const findSnapPositionInsideGroup = (children, rawCol, rawRow, innerCols, innerRows, totalCols = 24) => {
+    let bestCandidate;
+    for (const child of children) {
+        const rightEdge = child.x + child.cols;
+        const canFit = rightEdge + innerCols <= totalCols;
+        const isFree = canFit && isRegionFree(children, rightEdge, child.y, innerCols, innerRows);
+        if (!isFree) {
+            continue;
+        }
+        const nearX = Math.abs(rawCol - rightEdge) <= 2 || (rawCol >= child.x + Math.floor(child.cols / 2) && rawCol <= rightEdge + 1);
+        const nearY = Math.abs(rawRow - child.y) <= 2;
+        if (nearX && nearY) {
+            const dist = Math.abs(rawCol - rightEdge) + Math.abs(rawRow - child.y);
+            if (!bestCandidate || dist < bestCandidate.dist) {
+                bestCandidate = { col: rightEdge, row: child.y, dist };
+            }
+        }
+    }
+    if (bestCandidate) {
+        return { col: bestCandidate.col, row: bestCandidate.row };
+    }
+    const clampedCol = Math.max(0, Math.min(totalCols - innerCols, rawCol));
+    const clampedRow = Math.max(0, rawRow);
+    return { col: clampedCol, row: clampedRow };
+};
+/**
+ * Adjusts position of pair if horizontal overlap occurs.
+ */
+const adjustItemPair = (a, b) => {
+    const hOverlap = !(a.x + a.cols <= b.x || a.x >= b.x + b.cols);
+    if (hOverlap && b.y < a.y + a.rows) {
+        b.y = a.y + a.rows;
+        return true;
+    }
+    return false;
+};
+/**
+ * Resolves vertical collisions when inserting a new card at (newNode.x, newNode.y).
+ * Any existing card that horizontally overlaps and whose vertical span overlaps
+ * or is below the insertion point is pushed down so there is no overlap.
+ */
+export const resolveCollisionsAndInsert = (children, newNode) => {
+    const items = [...children];
+    for (const item of items) {
+        const hOverlap = !(item.x + item.cols <= newNode.x || item.x >= newNode.x + newNode.cols);
+        const vOverlap = !(item.y + item.rows <= newNode.y || item.y >= newNode.y + newNode.rows);
+        if (hOverlap && vOverlap) {
+            item.y = newNode.y + newNode.rows;
+        }
+    }
+    items.sort((a, b) => a.y - b.y);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < items.length; i++) {
+            for (let j = i + 1; j < items.length; j++) {
+                changed = adjustItemPair(items[i], items[j]) || changed;
+            }
+        }
+    }
+    children.push(newNode);
+};
+export function parseDropPayload(activePayload, dataTransfer) {
+    if (activePayload) {
+        return activePayload;
+    }
+    if (dataTransfer) {
+        try {
+            const raw = dataTransfer.getData('application/json');
+            if (raw) {
+                return JSON.parse(raw);
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+export const findHoveredGroup = (elements, canvasContainer, root) => {
+    const rootGridster = canvasContainer.querySelector('gridster');
+    for (const el of elements) {
+        const gridsterEl = (el.tagName.toLowerCase() === 'gridster' ? el : el.closest('gridster'));
+        if (gridsterEl && gridsterEl !== rootGridster) {
+            const outerItem = gridsterEl.closest('gridster-item');
+            const rootItems = rootGridster ? Array.from(rootGridster.querySelectorAll(':scope > gridster-item')) : [];
+            const idx = outerItem ? rootItems.indexOf(outerItem) : -1;
+            if (idx >= 0 && root.children?.[idx]) {
+                return { groupNode: root.children[idx], groupGridster: gridsterEl };
+            }
+        }
+    }
+    for (const el of elements) {
+        const itemEl = el.tagName.toLowerCase() === 'gridster-item' ? el : el.closest('gridster-item');
+        if (!itemEl) {
+            continue;
+        }
+        const rootItems = rootGridster ? Array.from(rootGridster.querySelectorAll(':scope > gridster-item')) : [];
+        const idx = rootItems.indexOf(itemEl);
+        if (idx >= 0 && root.children?.[idx]) {
+            const node = root.children[idx];
+            if ((node.children?.length ?? 0) > 0) {
+                return { groupNode: node, groupGridster: itemEl.querySelector('gridster') ?? itemEl };
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Calculates snapped spatial coordinates and pixel dimensions for drop ghost preview box.
+ */
+export const calculateDropGhost = (event, canvasContainer, root, payload, totalCols = 24) => {
+    if (typeof document === 'undefined' || !canvasContainer) {
+        return undefined;
+    }
+    const cardTitle = payload.title || 'Thẻ';
+    const cardIconClass = payload.iconClass;
+    const cardIconText = payload.iconText;
+    const payloadAny = payload;
+    let defaultCols = typeof payload.cols === 'number'
+        ? payload.cols
+        : (typeof payloadAny['defaultCols'] === 'number' ? payloadAny['defaultCols'] : (totalCols >= 24 ? 12 : 6));
+    let defaultRows = typeof payload.rows === 'number'
+        ? payload.rows
+        : (typeof payloadAny['defaultRows'] === 'number' ? payloadAny['defaultRows'] : 4);
+    if (typeof payloadAny['resolveNode'] === 'function') {
+        try {
+            const sample = payloadAny['resolveNode'](false);
+            if (sample) {
+                if (typeof sample.cols === 'number') {
+                    defaultCols = sample.cols;
+                }
+                if (typeof sample.rows === 'number') {
+                    defaultRows = sample.rows;
+                }
+            }
+        }
+        catch {
+            // fallback to default cols and rows
+        }
+    }
+    const stageEl = canvasContainer.querySelector('#bi-canvas-stage') ?? canvasContainer;
+    const stageRect = stageEl.getBoundingClientRect();
+    const rootGridster = stageEl.querySelector('gridster');
+    const gridsterEl = rootGridster ?? stageEl;
+    const gridsterRect = gridsterEl.getBoundingClientRect();
+    const unscaledWidth = gridsterEl.offsetWidth || gridsterEl.clientWidth || 0;
+    const zoom = (gridsterRect.width && unscaledWidth > 0)
+        ? Math.max(0.2, Math.min(3, gridsterRect.width / unscaledWidth))
+        : 1;
+    const elements = typeof document.elementsFromPoint === 'function'
+        ? document.elementsFromPoint(event.clientX, event.clientY)
+        : [];
+    const hovered = findHoveredGroup(elements, canvasContainer, root);
+    const stageMouseX = (event.clientX - stageRect.left) / zoom;
+    const stageMouseY = (event.clientY - stageRect.top) / zoom;
+    if (hovered) {
+        const { groupNode, groupGridster } = hovered;
+        const groupGridsterRect = groupGridster.getBoundingClientRect();
+        const groupStageLeft = (groupGridsterRect.left - stageRect.left) / zoom;
+        const groupStageTop = (groupGridsterRect.top - stageRect.top) / zoom;
+        let innerCols = defaultCols;
+        let innerRows = defaultRows;
+        if (typeof payloadAny['resolveNode'] === 'function') {
+            try {
+                const sampleInside = payloadAny['resolveNode'](true);
+                if (sampleInside) {
+                    if (typeof sampleInside.cols === 'number') {
+                        innerCols = sampleInside.cols;
+                    }
+                    if (typeof sampleInside.rows === 'number') {
+                        innerRows = sampleInside.rows;
+                    }
+                }
+            }
+            catch {
+                // fallback to default cols and rows
+            }
+        }
+        innerCols = Math.min(innerCols, totalCols);
+        const groupWidth = groupGridster.clientWidth || (groupGridsterRect.width / zoom) || 400;
+        const colStep = (groupWidth + 2) / totalCols;
+        const rowStep = 18;
+        const relX = (event.clientX - groupGridsterRect.left) / zoom + groupGridster.scrollLeft;
+        const relY = (event.clientY - groupGridsterRect.top) / zoom + groupGridster.scrollTop;
+        const rawCol = Math.floor(relX / colStep);
+        const rawRow = Math.floor(relY / rowStep);
+        const snap = findSnapPositionInsideGroup(groupNode.children ?? [], rawCol, rawRow, innerCols, innerRows, totalCols);
+        return {
+            col: snap.col,
+            row: snap.row,
+            cols: innerCols,
+            rows: innerRows,
+            pixelLeft: groupStageLeft + snap.col * colStep,
+            pixelTop: groupStageTop + snap.row * rowStep,
+            pixelWidth: Math.max(30, innerCols * colStep - 2),
+            pixelHeight: Math.max(20, innerRows * rowStep - 2),
+            isInsideGroup: true,
+            targetParentId: groupNode.id,
+            groupTitle: 'Khối ghép',
+            cardTitle,
+            cardIconClass,
+            cardIconText,
+            hoveredGridster: groupGridster,
+        };
+    }
+    const margin = 12;
+    const rowStep = 68;
+    const gridsterWidth = unscaledWidth || gridsterEl.clientWidth || 1200;
+    const colStep = Math.max(20, (gridsterWidth - margin) / totalCols);
+    const gridsterStageLeft = (gridsterRect.left - stageRect.left) / zoom;
+    const gridsterStageTop = (gridsterRect.top - stageRect.top) / zoom;
+    const relX = stageMouseX - gridsterStageLeft + gridsterEl.scrollLeft - margin;
+    const relY = stageMouseY - gridsterStageTop + gridsterEl.scrollTop - margin;
+    const itemCols = Math.min(defaultCols, totalCols);
+    const col = Math.max(0, Math.min(totalCols - itemCols, Math.floor(relX / colStep)));
+    const row = Math.max(0, Math.floor(relY / rowStep));
+    return {
+        col,
+        row,
+        cols: itemCols,
+        rows: defaultRows,
+        pixelLeft: gridsterStageLeft + margin + col * colStep,
+        pixelTop: gridsterStageTop + margin + row * rowStep,
+        pixelWidth: itemCols * colStep - margin,
+        pixelHeight: defaultRows * rowStep - margin,
+        isInsideGroup: false,
+        cardTitle,
+        cardIconClass,
+        cardIconText,
+        hoveredGridster: rootGridster ?? undefined,
+    };
+};
+/** Tìm khối theo id trong cây, đi sâu vào mọi container. */
+export const findNodeRecursive = (root, id) => {
+    if (root.id === id) {
+        return root;
+    }
+    for (const child of root.children ?? []) {
+        const found = findNodeRecursive(child, id);
+        if (found) {
+            return found;
+        }
+    }
+    return 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 const findParentRecursive = (root, id) => {
+    for (const child of root.children ?? []) {
+        if (child.id === id) {
+            return root;
+        }
+        const found = findParentRecursive(child, id);
+        if (found) {
+            return found;
+        }
+    }
+    return 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 const dropNodeAtCoordinates = (root, ghost, newNode) => {
+    const nodeToAdd = {
+        ...newNode,
+        id: newNode.id ?? uuid(),
+        x: ghost.col,
+        y: ghost.row,
+        cols: ghost.cols,
+        rows: ghost.rows,
+    };
+    if (ghost.isInsideGroup && ghost.targetParentId) {
+        const parentNode = findNodeRecursive(root, ghost.targetParentId);
+        if (!parentNode) {
+            return false;
+        }
+        parentNode.children = parentNode.children ?? [];
+        resolveCollisionsAndInsert(parentNode.children, nodeToAdd);
+        return true;
+    }
+    root.children = root.children ?? [];
+    resolveCollisionsAndInsert(root.children, nodeToAdd);
+    return true;
+};
+/** Khối có phải CONTAINER không — tức có khối con bên trong. */
+export const isContainerNode = (node) => (node.children?.length ?? 0) > 0;
+/** 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 const isNodeNestedInside = (root, nodeId) => {
+    if (!root?.children) {
+        return false;
+    }
+    return !root.children.some((child) => child.id === nodeId);
+};
+/**
+ * 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 const canToggleTypeNode = (root, node) => isContainerNode(node) || !isNodeNestedInside(root, node.id);
+/** Có được thêm khối vào BÊN TRONG khối này không. */
+export const canAddInsideNode = (root, node) => isContainerNode(node) && !isNodeNestedInside(root, node.id);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collision.define.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/defines/collision.define.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  T_gridLayout_dropGhost,\n  T_gridLayout_externalDragPayload,\n  T_gridLayout_newNode,\n  T_gridLayout_node,\n} from '../interfaces/grid-layout.interface';\nimport { uuid } from '@libs-ui/utils';\n\n/**\n * Checks whether the rectangular region [x, x + cols) x [y, y + rows)\n * is completely vacant among existing items.\n */\nexport const isRegionFree = (\n  children: Array<T_gridLayout_node>,\n  x: number,\n  y: number,\n  cols: number,\n  rows: number,\n  ignoredId?: string,\n): boolean => {\n  for (const child of children) {\n    if (ignoredId && child.id === ignoredId) {\n      continue;\n    }\n    const hOverlap = !(child.x + child.cols <= x || child.x >= x + cols);\n    const vOverlap = !(child.y + child.rows <= y || child.y >= y + rows);\n\n    if (hOverlap && vOverlap) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Computes optimal (col, row) inside a group container.\n * Snaps flush to adjacent card right edge if slot is vacant.\n */\nexport const findSnapPositionInsideGroup = (\n  children: Array<T_gridLayout_node>,\n  rawCol: number,\n  rawRow: number,\n  innerCols: number,\n  innerRows: number,\n  totalCols = 24,\n): { col: number; row: number } => {\n  let bestCandidate: { col: number; row: number; dist: number } | undefined;\n\n  for (const child of children) {\n    const rightEdge = child.x + child.cols;\n    const canFit = rightEdge + innerCols <= totalCols;\n    const isFree = canFit && isRegionFree(children, rightEdge, child.y, innerCols, innerRows);\n\n    if (!isFree) {\n      continue;\n    }\n\n    const nearX = Math.abs(rawCol - rightEdge) <= 2 || (rawCol >= child.x + Math.floor(child.cols / 2) && rawCol <= rightEdge + 1);\n    const nearY = Math.abs(rawRow - child.y) <= 2;\n\n    if (nearX && nearY) {\n      const dist = Math.abs(rawCol - rightEdge) + Math.abs(rawRow - child.y);\n\n      if (!bestCandidate || dist < bestCandidate.dist) {\n        bestCandidate = { col: rightEdge, row: child.y, dist };\n      }\n    }\n  }\n\n  if (bestCandidate) {\n    return { col: bestCandidate.col, row: bestCandidate.row };\n  }\n\n  const clampedCol = Math.max(0, Math.min(totalCols - innerCols, rawCol));\n  const clampedRow = Math.max(0, rawRow);\n\n  return { col: clampedCol, row: clampedRow };\n};\n\n/**\n * Adjusts position of pair if horizontal overlap occurs.\n */\nconst adjustItemPair = (a: T_gridLayout_node, b: T_gridLayout_node): boolean => {\n  const hOverlap = !(a.x + a.cols <= b.x || a.x >= b.x + b.cols);\n\n  if (hOverlap && b.y < a.y + a.rows) {\n    b.y = a.y + a.rows;\n\n    return true;\n  }\n\n  return false;\n};\n\n/**\n * Resolves vertical collisions when inserting a new card at (newNode.x, newNode.y).\n * Any existing card that horizontally overlaps and whose vertical span overlaps\n * or is below the insertion point is pushed down so there is no overlap.\n */\nexport const resolveCollisionsAndInsert = (\n  children: Array<T_gridLayout_node>,\n  newNode: T_gridLayout_node,\n): void => {\n  const items = [...children];\n\n  for (const item of items) {\n    const hOverlap = !(item.x + item.cols <= newNode.x || item.x >= newNode.x + newNode.cols);\n    const vOverlap = !(item.y + item.rows <= newNode.y || item.y >= newNode.y + newNode.rows);\n\n    if (hOverlap && vOverlap) {\n      item.y = newNode.y + newNode.rows;\n    }\n  }\n\n  items.sort((a, b) => a.y - b.y);\n  let changed = true;\n\n  while (changed) {\n    changed = false;\n    for (let i = 0; i < items.length; i++) {\n      for (let j = i + 1; j < items.length; j++) {\n        changed = adjustItemPair(items[i], items[j]) || changed;\n      }\n    }\n  }\n\n  children.push(newNode);\n};\n\nexport function parseDropPayload<T>(activePayload: T | undefined, dataTransfer: DataTransfer | null): T | undefined {\n  if (activePayload) {\n    return activePayload;\n  }\n  if (dataTransfer) {\n    try {\n      const raw = dataTransfer.getData('application/json');\n\n      if (raw) {\n        return JSON.parse(raw) as T;\n      }\n    } catch {\n      return undefined;\n    }\n  }\n\n  return undefined;\n}\n\ninterface I_hoveredGroup {\n  groupNode: T_gridLayout_node;\n  groupGridster: HTMLElement;\n}\n\nexport const findHoveredGroup = (\n  elements: Element[],\n  canvasContainer: HTMLElement,\n  root: T_gridLayout_node,\n): I_hoveredGroup | undefined => {\n  const rootGridster = canvasContainer.querySelector('gridster');\n\n  for (const el of elements) {\n    const gridsterEl = (el.tagName.toLowerCase() === 'gridster' ? el : el.closest('gridster')) as HTMLElement | null;\n\n    if (gridsterEl && gridsterEl !== rootGridster) {\n      const outerItem = gridsterEl.closest('gridster-item');\n      const rootItems = rootGridster ? Array.from(rootGridster.querySelectorAll(':scope > gridster-item')) : [];\n      const idx = outerItem ? rootItems.indexOf(outerItem) : -1;\n\n      if (idx >= 0 && root.children?.[idx]) {\n        return { groupNode: root.children[idx], groupGridster: gridsterEl };\n      }\n    }\n  }\n\n  for (const el of elements) {\n    const itemEl = el.tagName.toLowerCase() === 'gridster-item' ? el : el.closest('gridster-item');\n    if (!itemEl) {\n      continue;\n    }\n    const rootItems = rootGridster ? Array.from(rootGridster.querySelectorAll(':scope > gridster-item')) : [];\n    const idx = rootItems.indexOf(itemEl);\n    if (idx >= 0 && root.children?.[idx]) {\n      const node = root.children[idx];\n      if ((node.children?.length ?? 0) > 0) {\n        return { groupNode: node, groupGridster: (itemEl.querySelector('gridster') as HTMLElement | null) ?? (itemEl as HTMLElement) };\n      }\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Calculates snapped spatial coordinates and pixel dimensions for drop ghost preview box.\n */\nexport const calculateDropGhost = (\n  event: DragEvent,\n  canvasContainer: HTMLElement,\n  root: T_gridLayout_node,\n  payload: T_gridLayout_externalDragPayload,\n  totalCols = 24,\n): T_gridLayout_dropGhost | undefined => {\n  if (typeof document === 'undefined' || !canvasContainer) {\n    return undefined;\n  }\n\n  const cardTitle = payload.title || 'Thẻ';\n  const cardIconClass = payload.iconClass;\n  const cardIconText = payload.iconText;\n  const payloadAny = payload as Record<string, unknown>;\n  let defaultCols = typeof payload.cols === 'number'\n    ? payload.cols\n    : (typeof payloadAny['defaultCols'] === 'number' ? (payloadAny['defaultCols'] as number) : (totalCols >= 24 ? 12 : 6));\n  let defaultRows = typeof payload.rows === 'number'\n    ? payload.rows\n    : (typeof payloadAny['defaultRows'] === 'number' ? (payloadAny['defaultRows'] as number) : 4);\n\n  if (typeof payloadAny['resolveNode'] === 'function') {\n    try {\n      const sample = (payloadAny['resolveNode'] as (inside: boolean) => T_gridLayout_newNode | undefined)(false);\n      if (sample) {\n        if (typeof sample.cols === 'number') { defaultCols = sample.cols; }\n        if (typeof sample.rows === 'number') { defaultRows = sample.rows; }\n      }\n    } catch {\n      // fallback to default cols and rows\n    }\n  }\n\n  const stageEl = (canvasContainer.querySelector('#bi-canvas-stage') as HTMLElement | null) ?? canvasContainer;\n  const stageRect = stageEl.getBoundingClientRect();\n\n  const rootGridster = stageEl.querySelector('gridster') as HTMLElement | null;\n  const gridsterEl = rootGridster ?? stageEl;\n  const gridsterRect = gridsterEl.getBoundingClientRect();\n  const unscaledWidth = gridsterEl.offsetWidth || gridsterEl.clientWidth || 0;\n  const zoom = (gridsterRect.width && unscaledWidth > 0)\n    ? Math.max(0.2, Math.min(3, gridsterRect.width / unscaledWidth))\n    : 1;\n\n  const elements = typeof document.elementsFromPoint === 'function'\n    ? document.elementsFromPoint(event.clientX, event.clientY)\n    : [];\n  const hovered = findHoveredGroup(elements, canvasContainer, root);\n\n  const stageMouseX = (event.clientX - stageRect.left) / zoom;\n  const stageMouseY = (event.clientY - stageRect.top) / zoom;\n\n  if (hovered) {\n    const { groupNode, groupGridster } = hovered;\n    const groupGridsterRect = groupGridster.getBoundingClientRect();\n    const groupStageLeft = (groupGridsterRect.left - stageRect.left) / zoom;\n    const groupStageTop = (groupGridsterRect.top - stageRect.top) / zoom;\n\n    let innerCols = defaultCols;\n    let innerRows = defaultRows;\n    if (typeof payloadAny['resolveNode'] === 'function') {\n      try {\n        const sampleInside = (payloadAny['resolveNode'] as (inside: boolean) => T_gridLayout_newNode | undefined)(true);\n        if (sampleInside) {\n          if (typeof sampleInside.cols === 'number') { innerCols = sampleInside.cols; }\n          if (typeof sampleInside.rows === 'number') { innerRows = sampleInside.rows; }\n        }\n      } catch {\n        // fallback to default cols and rows\n      }\n    }\n    innerCols = Math.min(innerCols, totalCols);\n\n    const groupWidth = groupGridster.clientWidth || (groupGridsterRect.width / zoom) || 400;\n    const colStep = (groupWidth + 2) / totalCols;\n    const rowStep = 18;\n    const relX = (event.clientX - groupGridsterRect.left) / zoom + groupGridster.scrollLeft;\n    const relY = (event.clientY - groupGridsterRect.top) / zoom + groupGridster.scrollTop;\n    const rawCol = Math.floor(relX / colStep);\n    const rawRow = Math.floor(relY / rowStep);\n    const snap = findSnapPositionInsideGroup(\n      groupNode.children ?? [],\n      rawCol,\n      rawRow,\n      innerCols,\n      innerRows,\n      totalCols,\n    );\n\n    return {\n      col: snap.col,\n      row: snap.row,\n      cols: innerCols,\n      rows: innerRows,\n      pixelLeft: groupStageLeft + snap.col * colStep,\n      pixelTop: groupStageTop + snap.row * rowStep,\n      pixelWidth: Math.max(30, innerCols * colStep - 2),\n      pixelHeight: Math.max(20, innerRows * rowStep - 2),\n      isInsideGroup: true,\n      targetParentId: groupNode.id,\n      groupTitle: 'Khối ghép',\n      cardTitle,\n      cardIconClass,\n      cardIconText,\n      hoveredGridster: groupGridster as HTMLElement,\n    };\n  }\n\n  const margin = 12;\n  const rowStep = 68;\n  const gridsterWidth = unscaledWidth || gridsterEl.clientWidth || 1200;\n  const colStep = Math.max(20, (gridsterWidth - margin) / totalCols);\n  const gridsterStageLeft = (gridsterRect.left - stageRect.left) / zoom;\n  const gridsterStageTop = (gridsterRect.top - stageRect.top) / zoom;\n  const relX = stageMouseX - gridsterStageLeft + gridsterEl.scrollLeft - margin;\n  const relY = stageMouseY - gridsterStageTop + gridsterEl.scrollTop - margin;\n  const itemCols = Math.min(defaultCols, totalCols);\n  const col = Math.max(0, Math.min(totalCols - itemCols, Math.floor(relX / colStep)));\n  const row = Math.max(0, Math.floor(relY / rowStep));\n\n  return {\n    col,\n    row,\n    cols: itemCols,\n    rows: defaultRows,\n    pixelLeft: gridsterStageLeft + margin + col * colStep,\n    pixelTop: gridsterStageTop + margin + row * rowStep,\n    pixelWidth: itemCols * colStep - margin,\n    pixelHeight: defaultRows * rowStep - margin,\n    isInsideGroup: false,\n    cardTitle,\n    cardIconClass,\n    cardIconText,\n    hoveredGridster: (rootGridster as HTMLElement) ?? undefined,\n  };\n};\n\n\n/** Tìm khối theo id trong cây, đi sâu vào mọi container. */\nexport const findNodeRecursive = (root: T_gridLayout_node, id: string): T_gridLayout_node | undefined => {\n  if (root.id === id) {\n    return root;\n  }\n\n  for (const child of root.children ?? []) {\n    const found = findNodeRecursive(child, id);\n\n    if (found) {\n      return found;\n    }\n  }\n\n  return undefined;\n};\n\n/** Tìm khối CHA trực tiếp của một khối, đi sâu vào mọi container. */\nexport const findParentRecursive = (root: T_gridLayout_node, id: string): T_gridLayout_node | undefined => {\n  for (const child of root.children ?? []) {\n    if (child.id === id) {\n      return root;\n    }\n\n    const found = findParentRecursive(child, id);\n\n    if (found) {\n      return found;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Thả khối vào đúng ô mà ghost đang chỉ, đẩy các khối va chạm xuống dưới.\n *\n * Ghost đang nằm trong một container (`isInsideGroup`) thì thả vào ruột container đó; không tìm thấy\n * 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ả.\n */\nexport const dropNodeAtCoordinates = (\n  root: T_gridLayout_node,\n  ghost: T_gridLayout_dropGhost,\n  newNode: T_gridLayout_newNode\n): boolean => {\n  const nodeToAdd: T_gridLayout_node = {\n    ...newNode,\n    id: newNode.id ?? uuid(),\n    x: ghost.col,\n    y: ghost.row,\n    cols: ghost.cols,\n    rows: ghost.rows,\n  };\n\n  if (ghost.isInsideGroup && ghost.targetParentId) {\n    const parentNode = findNodeRecursive(root, ghost.targetParentId);\n\n    if (!parentNode) {\n      return false;\n    }\n    parentNode.children = parentNode.children ?? [];\n    resolveCollisionsAndInsert(parentNode.children, nodeToAdd);\n\n    return true;\n  }\n\n  root.children = root.children ?? [];\n  resolveCollisionsAndInsert(root.children, nodeToAdd);\n\n  return true;\n};\n\n\n/** Khối có phải CONTAINER không — tức có khối con bên trong. */\nexport const isContainerNode = (node: T_gridLayout_node): boolean => (node.children?.length ?? 0) > 0;\n\n/** 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). */\nexport const isNodeNestedInside = (root: T_gridLayout_node | undefined, nodeId: string): boolean => {\n  if (!root?.children) {\n    return false;\n  }\n\n  return !root.children.some((child) => child.id === nodeId);\n};\n\n/**\n * Có được đổi khối đơn ↔ container không.\n *\n * 🔴 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ự\n * 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\n * mỗi khi thư viện đổi trần lồng cấp mà không có gì báo.\n */\nexport const canToggleTypeNode = (root: T_gridLayout_node | undefined, node: T_gridLayout_node): boolean =>\n  isContainerNode(node) || !isNodeNestedInside(root, node.id);\n\n/** Có được thêm khối vào BÊN TRONG khối này không. */\nexport const canAddInsideNode = (root: T_gridLayout_node | undefined, node: T_gridLayout_node): boolean =>\n  isContainerNode(node) && !isNodeNestedInside(root, node.id);\n"]}

package/esm2022/defines/gridster-config.define.mjs

@@ -32,10 +32,9 @@ export const gridLayoutRootConfig = () => ({
     swapWhileDragging: true,
     draggable: {
         enabled: true,
-        // 🔴 KHÔNG được bỏ. Không có nó thì gridster vào chế độ kéo ngay từ `mousedown`, nên chỉ bấm
-        // CHỌN một khối là nó đã nhích theo dù chuột đứng yên. Lib tự huỷ kéo khi nhả chuột trước mốc
-        // này nên cú bấm chọn vẫn ăn nguyên vẹn.
-        delayStart: 160,
+        // delayStart: 0 vì kéo qua tay cầm chuyên dụng (dragHandleClass) và ignoreContent: true.
+        // Khi người dùng bấm vào thanh tay cầm là chủ động kéo, không cần trễ 160ms tránh huỷ kéo.
+        delayStart: 0,
         // 🔴 `checkDragHandleClass` duyệt DOM từ chỗ bấm NGƯỢC LÊN CHA, và trên MỖI node nó kiểm
         // `dragHandleClass` TRƯỚC `ignoreContentClass`. Vì vậy một phần tử KHÔNG được mang cả hai class
         // cùng lúc — mang cả hai thì lib gặp tay cầm trước, trả `true`, class chặn không tới lượt.
@@ -120,4 +119,4 @@ export const gridLayoutNestedConfig = () => ({
  * Xảy ra trong nhịp giữa lúc component dựng và lúc `init()` chạy.
  */
 export const emptyRootNode = () => ({ id: 'root', x: 0, y: 0, cols: 12, rows: 0, children: [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gridster-config.define.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/defines/gridster-config.define.ts"],"names":[],"mappings":"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","sourcesContent":["import { CompactType, DisplayGrid, GridsterConfig, GridType } from 'gridster18';\nimport { T_gridLayout_node } from '../interfaces/grid-layout.interface';\n\n/**\n * Cấu hình gridster cho lưới CẤP TRANG.\n *\n * Mọi giá trị dưới đây đều đến từ một lỗi đã đo được trên sản phẩm thật, không phải chọn theo cảm\n * tính. Đổi bất kỳ dòng nào có dấu 🔴 sẽ làm sống lại đúng lỗi ghi trong comment.\n */\nexport const gridLayoutRootConfig = (): GridsterConfig => ({\n  // 🔴 VerticalFixed — CẤM đổi sang Fit hay ScrollVertical.\n  // `Fit` chia đều chiều cao khung cho số hàng đang dùng, nên card khai `rows: 2` phình từ 124px lên\n  // 247px. `ScrollVertical` KHÔNG đọc `fixedRowHeight` (mã lib: chỉ `Fixed` và `VerticalFixed` đọc).\n  gridType: GridType.VerticalFixed,\n\n  // 🔴 None — CẤM quay lại CompactUp.\n  // `CompactUp` hút mọi khối lên sát nhau NGAY sau mỗi thao tác, nên:\n  //  · kéo mép dưới cho khối cao thêm → chỗ khối dưới vừa nhường bị hút lấp lại tức thì, cú kéo bị\n  //    `checkGridCollision` báo va chạm rồi HOÀN NGUYÊN (khối đứng im dù kéo);\n  //  · kéo thả đổi vị trí → khối vừa nhường chỗ bị hút về ngay, khối đang kéo không có chỗ đặt và\n  //    treo lơ lửng giữa hai khối.\n  // Muốn dồn khít thì gọi `sapGon()` của service.\n  compactType: CompactType.None,\n  displayGrid: DisplayGrid.OnDragAndResize,\n\n  // 🔴 pushItems: true — CẤM để false.\n  // `swap` của lib CHỈ hoán vị được HAI KHỐI CÙNG KÍCH THƯỚC (mã lib `checkSwap`: tính diffX/diffY\n  // rồi hoán vị, lệch kích thước thì `checkCollision` báo va chạm và hoàn nguyên). Khối 3x2 gặp\n  // container 7x5 nên không swap được, mà `pushItems: false` cũng không cho container nhường đường\n  // → BẾ TẮC: khối đang kéo không đặt được ở đâu.\n  pushItems: true,\n  // chỉ đẩy XUỐNG: đẩy ngang làm xô lệch bố cục cột người dùng vừa đặt\n  pushDirections: { north: false, east: false, south: true, west: false },\n  pushResizeItems: true,\n  swap: true,\n  swapWhileDragging: true,\n\n  draggable: {\n    enabled: true,\n    // 🔴 KHÔNG được bỏ. Không có nó thì gridster vào chế độ kéo ngay từ `mousedown`, nên chỉ bấm\n    // CHỌN một khối là nó đã nhích theo dù chuột đứng yên. Lib tự huỷ kéo khi nhả chuột trước mốc\n    // này nên cú bấm chọn vẫn ăn nguyên vẹn.\n    delayStart: 160,\n    // 🔴 `checkDragHandleClass` duyệt DOM từ chỗ bấm NGƯỢC LÊN CHA, và trên MỖI node nó kiểm\n    // `dragHandleClass` TRƯỚC `ignoreContentClass`. Vì vậy một phần tử KHÔNG được mang cả hai class\n    // cùng lúc — mang cả hai thì lib gặp tay cầm trước, trả `true`, class chặn không tới lượt.\n    ignoreContentClass: 'libs-ui-grid-layout-block-parent-drag',\n    ignoreContent: true,\n    dragHandleClass: 'libs-ui-grid-layout-drag-handle',\n  },\n\n  resizable: {\n    enabled: true,\n    // đủ 8 hướng như cửa sổ thường; chỉ có góc dưới-phải thì quá khó trúng\n    handles: { s: true, e: true, n: true, w: true, se: true, ne: true, sw: true, nw: true },\n  },\n\n  margin: 12,\n  outerMargin: true,\n  outerMarginBottom: 40,\n  minCols: 12,\n  maxCols: 12,\n  minRows: 2,\n\n  // 🔴 KHÔNG giới hạn chiều cao khối. Lib có BA trần mặc định phải vô hiệu hoá CÙNG LÚC, thiếu một\n  // cái là vẫn bị chặn: `maxItemRows: 50` · `maxItemCols: 50` · `maxItemArea: 2500` (trần DIỆN TÍCH\n  // cols × rows — khó thấy nhất: khối 12 cột chỉ cần 209 hàng là đụng trần dù hai trần kia còn dư).\n  // `maxRows` là trần của CẢ LƯỚI, cũng phải nới theo.\n  maxRows: 5000,\n  maxItemRows: 5000,\n  maxItemCols: 12,\n  maxItemArea: 60000,\n\n  // 🔴 Trần LỚP CHỒNG. Mặc định của lib là 2 — quá thấp: khi bật chồng khối, thư viện gán mỗi khối\n  // một lớp riêng để chúng khác nhau, nên chỉ 3 khối là đã đụng trần và các khối sau lại rơi về\n  // cùng lớp, tức chồng nhau bị chặn trở lại.\n  maxLayerIndex: 5000,\n\n  setGridSize: true,\n  fixedRowHeight: 56,\n  defaultItemCols: 3,\n  defaultItemRows: 2,\n  minItemRows: 1,\n  mobileBreakpoint: -1,\n});\n\n/**\n * Cấu hình cho lưới LỒNG (ruột một container).\n *\n * Kế thừa lưới trang rồi ghi đè phần khác biệt. Ba điểm quan trọng nhất: `setGridSize` phải TẮT,\n * tay cầm phải mang TÊN RIÊNG, và tự-cuộn-khi-kéo phải TẮT.\n */\nexport const gridLayoutNestedConfig = (): GridsterConfig => ({\n  ...gridLayoutRootConfig(),\n\n  // 🔴 PHẢI tắt cho lưới lồng. `setGridSize` làm gridster tự ghi style width/height lên CHÍNH nó,\n  // sinh vòng lặp đo-rồi-ghi với ResizeObserver của khung ngoài (khung đổi → onResize xoá style →\n  // setGridSize ghi lại) → lưới con co dần về 64x64px trong khung 868px.\n  setGridSize: false,\n\n  // khe 2px: khối con là các dòng thông tin của CÙNG một card, khe rộng làm chúng trông như card rời\n  margin: 2,\n  // Lưới lồng KHÔNG tự chừa lề — lề là của VỎ container (`containerPadding`), không phải của lưới.\n  // Đặt ở vỏ thì ruột co lại đúng bằng phần còn lại, tay cầm resize của khối con luôn nằm trong tầm\n  // chuột (người dùng chốt 28/08/2026: \"lưới cha có padding chứ ko phải con\").\n  outerMargin: false,\n  outerMarginBottom: 0,\n\n  // hàng 16px cho bước kéo mịn, và sàn 1 hàng = 16px nên khối co được nhỏ hơn nhiều\n  fixedRowHeight: 16,\n  minRows: 1,\n  minItemRows: 1,\n  defaultItemCols: 2,\n  defaultItemRows: 2,\n\n  // 🔴 Tay cầm RIÊNG — CẤM dùng chung tên với lưới trang.\n  // `checkDragHandleClass` trả `true` ở node ĐẦU TIÊN có `dragHandleClass`. Dùng chung một tên thì\n  // lưới CHA cũng nhận ra tay cầm của khối con và nhấc luôn container.\n  draggable: {\n    ...gridLayoutRootConfig().draggable,\n    dragHandleClass: 'libs-ui-grid-layout-drag-handle-child',\n  },\n\n  // 🔴 KÉO MÉP thì khối dưới ĐỨNG YÊN, chỉ khoảng trống giữa hai khối co giãn. Bật (kế thừa từ lưới\n  // trang) thì mỗi cú kéo đẩy dồn cả cột xuống — người dùng chỉ muốn một khối to hơn một chút mà cả\n  // card dài ra. `pushItems` vẫn giữ: nó lo việc KÉO THẢ đổi chỗ, khác việc đổi kích thước.\n  pushResizeItems: false,\n\n  // 🔴 Tắt tự cuộn khi kéo tới sát mép. Lib thấy chuột gần biên là cuộn lưới theo\n  // (`scrollSensitivity`), nhưng lưới con nằm trong card có `overflow: hidden` — cuộn ở đây đẩy khối\n  // con ra NGOÀI khung container rồi kẹt luôn ở đó.\n  disableScrollHorizontal: true,\n  disableScrollVertical: true,\n});\n\n/**\n * Cây rỗng dùng khi chưa có dữ liệu — mặt phẳng vẽ ra một lưới trống thay vì vỡ.\n * Xảy ra trong nhịp giữa lúc component dựng và lúc `init()` chạy.\n */\nexport const emptyRootNode = (): T_gridLayout_node => ({ id: 'root', x: 0, y: 0, cols: 12, rows: 0, children: [] });\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gridster-config.define.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/grid-layout/src/defines/gridster-config.define.ts"],"names":[],"mappings":"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","sourcesContent":["import { CompactType, DisplayGrid, GridsterConfig, GridType } from 'gridster18';\nimport { T_gridLayout_node } from '../interfaces/grid-layout.interface';\n\n/**\n * Cấu hình gridster cho lưới CẤP TRANG.\n *\n * Mọi giá trị dưới đây đều đến từ một lỗi đã đo được trên sản phẩm thật, không phải chọn theo cảm\n * tính. Đổi bất kỳ dòng nào có dấu 🔴 sẽ làm sống lại đúng lỗi ghi trong comment.\n */\nexport const gridLayoutRootConfig = (): GridsterConfig => ({\n  // 🔴 VerticalFixed — CẤM đổi sang Fit hay ScrollVertical.\n  // `Fit` chia đều chiều cao khung cho số hàng đang dùng, nên card khai `rows: 2` phình từ 124px lên\n  // 247px. `ScrollVertical` KHÔNG đọc `fixedRowHeight` (mã lib: chỉ `Fixed` và `VerticalFixed` đọc).\n  gridType: GridType.VerticalFixed,\n\n  // 🔴 None — CẤM quay lại CompactUp.\n  // `CompactUp` hút mọi khối lên sát nhau NGAY sau mỗi thao tác, nên:\n  //  · kéo mép dưới cho khối cao thêm → chỗ khối dưới vừa nhường bị hút lấp lại tức thì, cú kéo bị\n  //    `checkGridCollision` báo va chạm rồi HOÀN NGUYÊN (khối đứng im dù kéo);\n  //  · kéo thả đổi vị trí → khối vừa nhường chỗ bị hút về ngay, khối đang kéo không có chỗ đặt và\n  //    treo lơ lửng giữa hai khối.\n  // Muốn dồn khít thì gọi `sapGon()` của service.\n  compactType: CompactType.None,\n  displayGrid: DisplayGrid.OnDragAndResize,\n\n  // 🔴 pushItems: true — CẤM để false.\n  // `swap` của lib CHỈ hoán vị được HAI KHỐI CÙNG KÍCH THƯỚC (mã lib `checkSwap`: tính diffX/diffY\n  // rồi hoán vị, lệch kích thước thì `checkCollision` báo va chạm và hoàn nguyên). Khối 3x2 gặp\n  // container 7x5 nên không swap được, mà `pushItems: false` cũng không cho container nhường đường\n  // → BẾ TẮC: khối đang kéo không đặt được ở đâu.\n  pushItems: true,\n  // chỉ đẩy XUỐNG: đẩy ngang làm xô lệch bố cục cột người dùng vừa đặt\n  pushDirections: { north: false, east: false, south: true, west: false },\n  pushResizeItems: true,\n  swap: true,\n  swapWhileDragging: true,\n\n  draggable: {\n    enabled: true,\n    // delayStart: 0 vì kéo qua tay cầm chuyên dụng (dragHandleClass) và ignoreContent: true.\n    // Khi người dùng bấm vào thanh tay cầm là chủ động kéo, không cần trễ 160ms tránh huỷ kéo.\n    delayStart: 0,\n    // 🔴 `checkDragHandleClass` duyệt DOM từ chỗ bấm NGƯỢC LÊN CHA, và trên MỖI node nó kiểm\n    // `dragHandleClass` TRƯỚC `ignoreContentClass`. Vì vậy một phần tử KHÔNG được mang cả hai class\n    // cùng lúc — mang cả hai thì lib gặp tay cầm trước, trả `true`, class chặn không tới lượt.\n    ignoreContentClass: 'libs-ui-grid-layout-block-parent-drag',\n    ignoreContent: true,\n    dragHandleClass: 'libs-ui-grid-layout-drag-handle',\n  },\n\n  resizable: {\n    enabled: true,\n    // đủ 8 hướng như cửa sổ thường; chỉ có góc dưới-phải thì quá khó trúng\n    handles: { s: true, e: true, n: true, w: true, se: true, ne: true, sw: true, nw: true },\n  },\n\n  margin: 12,\n  outerMargin: true,\n  outerMarginBottom: 40,\n  minCols: 12,\n  maxCols: 12,\n  minRows: 2,\n\n  // 🔴 KHÔNG giới hạn chiều cao khối. Lib có BA trần mặc định phải vô hiệu hoá CÙNG LÚC, thiếu một\n  // cái là vẫn bị chặn: `maxItemRows: 50` · `maxItemCols: 50` · `maxItemArea: 2500` (trần DIỆN TÍCH\n  // cols × rows — khó thấy nhất: khối 12 cột chỉ cần 209 hàng là đụng trần dù hai trần kia còn dư).\n  // `maxRows` là trần của CẢ LƯỚI, cũng phải nới theo.\n  maxRows: 5000,\n  maxItemRows: 5000,\n  maxItemCols: 12,\n  maxItemArea: 60000,\n\n  // 🔴 Trần LỚP CHỒNG. Mặc định của lib là 2 — quá thấp: khi bật chồng khối, thư viện gán mỗi khối\n  // một lớp riêng để chúng khác nhau, nên chỉ 3 khối là đã đụng trần và các khối sau lại rơi về\n  // cùng lớp, tức chồng nhau bị chặn trở lại.\n  maxLayerIndex: 5000,\n\n  setGridSize: true,\n  fixedRowHeight: 56,\n  defaultItemCols: 3,\n  defaultItemRows: 2,\n  minItemRows: 1,\n  mobileBreakpoint: -1,\n});\n\n/**\n * Cấu hình cho lưới LỒNG (ruột một container).\n *\n * Kế thừa lưới trang rồi ghi đè phần khác biệt. Ba điểm quan trọng nhất: `setGridSize` phải TẮT,\n * tay cầm phải mang TÊN RIÊNG, và tự-cuộn-khi-kéo phải TẮT.\n */\nexport const gridLayoutNestedConfig = (): GridsterConfig => ({\n  ...gridLayoutRootConfig(),\n\n  // 🔴 PHẢI tắt cho lưới lồng. `setGridSize` làm gridster tự ghi style width/height lên CHÍNH nó,\n  // sinh vòng lặp đo-rồi-ghi với ResizeObserver của khung ngoài (khung đổi → onResize xoá style →\n  // setGridSize ghi lại) → lưới con co dần về 64x64px trong khung 868px.\n  setGridSize: false,\n\n  // khe 2px: khối con là các dòng thông tin của CÙNG một card, khe rộng làm chúng trông như card rời\n  margin: 2,\n  // Lưới lồng KHÔNG tự chừa lề — lề là của VỎ container (`containerPadding`), không phải của lưới.\n  // Đặt ở vỏ thì ruột co lại đúng bằng phần còn lại, tay cầm resize của khối con luôn nằm trong tầm\n  // chuột (người dùng chốt 28/08/2026: \"lưới cha có padding chứ ko phải con\").\n  outerMargin: false,\n  outerMarginBottom: 0,\n\n  // hàng 16px cho bước kéo mịn, và sàn 1 hàng = 16px nên khối co được nhỏ hơn nhiều\n  fixedRowHeight: 16,\n  minRows: 1,\n  minItemRows: 1,\n  defaultItemCols: 2,\n  defaultItemRows: 2,\n\n  // 🔴 Tay cầm RIÊNG — CẤM dùng chung tên với lưới trang.\n  // `checkDragHandleClass` trả `true` ở node ĐẦU TIÊN có `dragHandleClass`. Dùng chung một tên thì\n  // lưới CHA cũng nhận ra tay cầm của khối con và nhấc luôn container.\n  draggable: {\n    ...gridLayoutRootConfig().draggable,\n    dragHandleClass: 'libs-ui-grid-layout-drag-handle-child',\n  },\n\n  // 🔴 KÉO MÉP thì khối dưới ĐỨNG YÊN, chỉ khoảng trống giữa hai khối co giãn. Bật (kế thừa từ lưới\n  // trang) thì mỗi cú kéo đẩy dồn cả cột xuống — người dùng chỉ muốn một khối to hơn một chút mà cả\n  // card dài ra. `pushItems` vẫn giữ: nó lo việc KÉO THẢ đổi chỗ, khác việc đổi kích thước.\n  pushResizeItems: false,\n\n  // 🔴 Tắt tự cuộn khi kéo tới sát mép. Lib thấy chuột gần biên là cuộn lưới theo\n  // (`scrollSensitivity`), nhưng lưới con nằm trong card có `overflow: hidden` — cuộn ở đây đẩy khối\n  // con ra NGOÀI khung container rồi kẹt luôn ở đó.\n  disableScrollHorizontal: true,\n  disableScrollVertical: true,\n});\n\n/**\n * Cây rỗng dùng khi chưa có dữ liệu — mặt phẳng vẽ ra một lưới trống thay vì vỡ.\n * Xảy ra trong nhịp giữa lúc component dựng và lúc `init()` chạy.\n */\nexport const emptyRootNode = (): T_gridLayout_node => ({ id: 'root', x: 0, y: 0, cols: 12, rows: 0, children: [] });\n"]}

package/esm2022/drag-controller.mjs

@@ -0,0 +1,89 @@
+import { calculateDropGhost } from './defines/collision.define';
+/** Lớp CSS bật ô li của một lưới trong lúc người dùng đang kéo khối vào. */
+const LOP_HIEN_O_LI = 'display-grid';
+/**
+ * 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 class LibsUiGridLayoutDragController {
+    payload;
+    hoveredElement;
+    rootGridsterElement;
+    /** Payload của khối đang được kéo; `undefined` khi không có lượt kéo nào. */
+    get ActivePayload() {
+        return this.payload;
+    }
+    /** Gọi ở `dragstart` của thẻ trong palette. */
+    onDragStart(payload) {
+        this.payload = payload;
+    }
+    /** Gọi ở `dragend` — dọn sạch mọi ô li đang bật. */
+    onDragEnd(container) {
+        this.payload = undefined;
+        this.cleanupAll(container);
+    }
+    /** Tắt ô li của container đang hover. */
+    cleanupHoveredGroup() {
+        if (!this.hoveredElement) {
+            return;
+        }
+        this.hoveredElement.classList.remove(LOP_HIEN_O_LI);
+        this.hoveredElement = undefined;
+    }
+    /** 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) {
+        if (this.rootGridsterElement) {
+            this.rootGridsterElement.classList.remove(LOP_HIEN_O_LI);
+            this.rootGridsterElement = undefined;
+        }
+        container?.querySelectorAll(`gridster.${LOP_HIEN_O_LI}`).forEach((el) => el.classList.remove(LOP_HIEN_O_LI));
+    }
+    /** Tắt toàn bộ ô li đang bật. */
+    cleanupAll(container) {
+        this.cleanupHoveredGroup();
+        this.cleanupRootGrid(container);
+    }
+    /**
+     * 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, container, root, totalCols) {
+        event.preventDefault();
+        if (event.dataTransfer) {
+            event.dataTransfer.dropEffect = 'copy';
+        }
+        if (!container || !root || !this.payload) {
+            return undefined;
+        }
+        this.showRootGrid(container);
+        const ghost = calculateDropGhost(event, container, root, this.payload, totalCols);
+        if (!ghost?.isInsideGroup || !ghost.hoveredGridster) {
+            this.cleanupHoveredGroup();
+            return ghost;
+        }
+        if (this.hoveredElement !== ghost.hoveredGridster) {
+            this.cleanupHoveredGroup();
+            ghost.hoveredGridster.classList.add(LOP_HIEN_O_LI);
+            this.hoveredElement = ghost.hoveredGridster;
+        }
+        return ghost;
+    }
+    /** 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. */
+    showRootGrid(container) {
+        const rootGridster = container.querySelector('gridster') ?? undefined;
+        if (!rootGridster) {
+            return;
+        }
+        if (this.rootGridsterElement && this.rootGridsterElement !== rootGridster) {
+            this.rootGridsterElement.classList.remove(LOP_HIEN_O_LI);
+        }
+        rootGridster.classList.add(LOP_HIEN_O_LI);
+        this.rootGridsterElement = rootGridster;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-controller.js","sourceRoot":"","sources":["../../../../../libs-ui/services/grid-layout/src/drag-controller.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,4EAA4E;AAC5E,MAAM,aAAa,GAAG,cAAc,CAAC;AAErC;;;;;;;;GAQG;AACH,MAAM,OAAO,8BAA8B;IACjC,OAAO,CAAoC;IAC3C,cAAc,CAAe;IAC7B,mBAAmB,CAAe;IAE1C,6EAA6E;IAC7E,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,+CAA+C;IAC/C,WAAW,CAAC,OAAyC;QACnD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,oDAAoD;IACpD,SAAS,CAAC,SAAuB;QAC/B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED,yCAAyC;IACzC,mBAAmB;QACjB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QACpD,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;IAClC,CAAC;IAED,wEAAwE;IACxE,eAAe,CAAC,SAAuB;QACrC,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YACzD,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;QACvC,CAAC;QACD,SAAS,EAAE,gBAAgB,CAAC,YAAY,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;IAC/G,CAAC;IAED,iCAAiC;IACjC,UAAU,CAAC,SAAuB;QAChC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,UAAU,CACR,KAAgB,EAChB,SAAkC,EAClC,IAAmC,EACnC,SAAkB;QAElB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACvB,KAAK,CAAC,YAAY,CAAC,UAAU,GAAG,MAAM,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACzC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAE7B,MAAM,KAAK,GAAG,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAElF,IAAI,CAAC,KAAK,EAAE,aAAa,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;YACpD,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAE3B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC,eAAe,EAAE,CAAC;YAClD,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;YACnD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,eAAe,CAAC;QAC9C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,0FAA0F;IAClF,YAAY,CAAC,SAAsB;QACzC,MAAM,YAAY,GAAI,SAAS,CAAC,aAAa,CAAC,UAAU,CAAwB,IAAI,SAAS,CAAC;QAE9F,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,KAAK,YAAY,EAAE,CAAC;YAC1E,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAC3D,CAAC;QACD,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC1C,IAAI,CAAC,mBAAmB,GAAG,YAAY,CAAC;IAC1C,CAAC;CACF","sourcesContent":["import {\n  T_gridLayout_dropGhost,\n  T_gridLayout_externalDragPayload,\n  T_gridLayout_node,\n} from './interfaces/grid-layout.interface';\nimport { calculateDropGhost } from './defines/collision.define';\n\n/** Lớp CSS bật ô li của một lưới trong lúc người dùng đang kéo khối vào. */\nconst LOP_HIEN_O_LI = 'display-grid';\n\n/**\n * 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.\n *\n * 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\n * vào trong), tắt đúng lúc, và trả về ghost để nơi dùng vẽ khung xem trước.\n *\n * 🔴 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\n * 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.\n */\nexport class LibsUiGridLayoutDragController {\n  private payload?: T_gridLayout_externalDragPayload;\n  private hoveredElement?: HTMLElement;\n  private rootGridsterElement?: HTMLElement;\n\n  /** Payload của khối đang được kéo; `undefined` khi không có lượt kéo nào. */\n  get ActivePayload(): T_gridLayout_externalDragPayload | undefined {\n    return this.payload;\n  }\n\n  /** Gọi ở `dragstart` của thẻ trong palette. */\n  onDragStart(payload: T_gridLayout_externalDragPayload): void {\n    this.payload = payload;\n  }\n\n  /** Gọi ở `dragend` — dọn sạch mọi ô li đang bật. */\n  onDragEnd(container?: HTMLElement): void {\n    this.payload = undefined;\n    this.cleanupAll(container);\n  }\n\n  /** Tắt ô li của container đang hover. */\n  cleanupHoveredGroup(): void {\n    if (!this.hoveredElement) {\n      return;\n    }\n    this.hoveredElement.classList.remove(LOP_HIEN_O_LI);\n    this.hoveredElement = undefined;\n  }\n\n  /** Tắt ô li của lưới gốc, và quét sạch lớp còn sót trong khung chứa. */\n  cleanupRootGrid(container?: HTMLElement): void {\n    if (this.rootGridsterElement) {\n      this.rootGridsterElement.classList.remove(LOP_HIEN_O_LI);\n      this.rootGridsterElement = undefined;\n    }\n    container?.querySelectorAll(`gridster.${LOP_HIEN_O_LI}`).forEach((el) => el.classList.remove(LOP_HIEN_O_LI));\n  }\n\n  /** Tắt toàn bộ ô li đang bật. */\n  cleanupAll(container?: HTMLElement): void {\n    this.cleanupHoveredGroup();\n    this.cleanupRootGrid(container);\n  }\n\n  /**\n   * 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\n   * tự bật ô li của lưới đang được kéo tới.\n   */\n  onDragOver(\n    event: DragEvent,\n    container: HTMLElement | undefined,\n    root: T_gridLayout_node | undefined,\n    totalCols?: number\n  ): T_gridLayout_dropGhost | undefined {\n    event.preventDefault();\n    if (event.dataTransfer) {\n      event.dataTransfer.dropEffect = 'copy';\n    }\n    if (!container || !root || !this.payload) {\n      return undefined;\n    }\n    this.showRootGrid(container);\n\n    const ghost = calculateDropGhost(event, container, root, this.payload, totalCols);\n\n    if (!ghost?.isInsideGroup || !ghost.hoveredGridster) {\n      this.cleanupHoveredGroup();\n\n      return ghost;\n    }\n\n    if (this.hoveredElement !== ghost.hoveredGridster) {\n      this.cleanupHoveredGroup();\n      ghost.hoveredGridster.classList.add(LOP_HIEN_O_LI);\n      this.hoveredElement = ghost.hoveredGridster;\n    }\n\n    return ghost;\n  }\n\n  /** 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. */\n  private showRootGrid(container: HTMLElement): void {\n    const rootGridster = (container.querySelector('gridster') as HTMLElement | null) ?? undefined;\n\n    if (!rootGridster) {\n      return;\n    }\n\n    if (this.rootGridsterElement && this.rootGridsterElement !== rootGridster) {\n      this.rootGridsterElement.classList.remove(LOP_HIEN_O_LI);\n    }\n    rootGridster.classList.add(LOP_HIEN_O_LI);\n    this.rootGridsterElement = rootGridster;\n  }\n}\n"]}