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

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

@@ -0,0 +1,123 @@
+import { CompactType, DisplayGrid, GridType } from 'gridster18';
+/**
+ * Cấu hình gridster cho lưới CẤP TRANG.
+ *
+ * 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
+ * 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.
+ */
+export const gridLayoutRootConfig = () => ({
+    // 🔴 VerticalFixed — CẤM đổi sang Fit hay ScrollVertical.
+    // `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
+    // 247px. `ScrollVertical` KHÔNG đọc `fixedRowHeight` (mã lib: chỉ `Fixed` và `VerticalFixed` đọc).
+    gridType: GridType.VerticalFixed,
+    // 🔴 None — CẤM quay lại CompactUp.
+    // `CompactUp` hút mọi khối lên sát nhau NGAY sau mỗi thao tác, 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ị
+    //    `checkGridCollision` báo va chạm rồi HOÀN NGUYÊN (khối đứng im dù kéo);
+    //  · 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à
+    //    treo lơ lửng giữa hai khối.
+    // Muốn dồn khít thì gọi `sapGon()` của service.
+    compactType: CompactType.None,
+    displayGrid: DisplayGrid.OnDragAndResize,
+    // 🔴 pushItems: true — CẤM để false.
+    // `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
+    // 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
+    // container 7x5 nên không swap được, mà `pushItems: false` cũng không cho container nhường đường
+    // → BẾ TẮC: khối đang kéo không đặt được ở đâu.
+    pushItems: true,
+    // chỉ đẩy XUỐNG: đẩy ngang làm xô lệch bố cục cột người dùng vừa đặt
+    pushDirections: { north: false, east: false, south: true, west: false },
+    pushResizeItems: true,
+    swap: true,
+    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,
+        // 🔴 `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.
+        ignoreContentClass: 'libs-ui-grid-layout-block-parent-drag',
+        ignoreContent: true,
+        dragHandleClass: 'libs-ui-grid-layout-drag-handle',
+    },
+    resizable: {
+        enabled: true,
+        // đủ 8 hướng như cửa sổ thường; chỉ có góc dưới-phải thì quá khó trúng
+        handles: { s: true, e: true, n: true, w: true, se: true, ne: true, sw: true, nw: true },
+    },
+    margin: 12,
+    outerMargin: true,
+    outerMarginBottom: 40,
+    minCols: 12,
+    maxCols: 12,
+    minRows: 2,
+    // 🔴 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
+    // cái là vẫn bị chặn: `maxItemRows: 50` · `maxItemCols: 50` · `maxItemArea: 2500` (trần DIỆN TÍCH
+    // 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ư).
+    // `maxRows` là trần của CẢ LƯỚI, cũng phải nới theo.
+    maxRows: 5000,
+    maxItemRows: 5000,
+    maxItemCols: 12,
+    maxItemArea: 60000,
+    // 🔴 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
+    // 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ề
+    // cùng lớp, tức chồng nhau bị chặn trở lại.
+    maxLayerIndex: 5000,
+    setGridSize: true,
+    fixedRowHeight: 56,
+    defaultItemCols: 3,
+    defaultItemRows: 2,
+    minItemRows: 1,
+    mobileBreakpoint: -1,
+});
+/**
+ * Cấu hình cho lưới LỒNG (ruột một container).
+ *
+ * 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,
+ * tay cầm phải mang TÊN RIÊNG, và tự-cuộn-khi-kéo phải TẮT.
+ */
+export const gridLayoutNestedConfig = () => ({
+    ...gridLayoutRootConfig(),
+    // 🔴 PHẢI tắt cho lưới lồng. `setGridSize` làm gridster tự ghi style width/height lên CHÍNH nó,
+    // sinh vòng lặp đo-rồi-ghi với ResizeObserver của khung ngoài (khung đổi → onResize xoá style →
+    // setGridSize ghi lại) → lưới con co dần về 64x64px trong khung 868px.
+    setGridSize: false,
+    // 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
+    margin: 2,
+    // 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.
+    // Đặ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
+    // chuột (người dùng chốt 28/08/2026: "lưới cha có padding chứ ko phải con").
+    outerMargin: false,
+    outerMarginBottom: 0,
+    // 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
+    fixedRowHeight: 16,
+    minRows: 1,
+    minItemRows: 1,
+    defaultItemCols: 2,
+    defaultItemRows: 2,
+    // 🔴 Tay cầm RIÊNG — CẤM dùng chung tên với lưới trang.
+    // `checkDragHandleClass` trả `true` ở node ĐẦU TIÊN có `dragHandleClass`. Dùng chung một tên thì
+    // lưới CHA cũng nhận ra tay cầm của khối con và nhấc luôn container.
+    draggable: {
+        ...gridLayoutRootConfig().draggable,
+        dragHandleClass: 'libs-ui-grid-layout-drag-handle-child',
+    },
+    // 🔴 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
+    // 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ả
+    // 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.
+    pushResizeItems: false,
+    // 🔴 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
+    // (`scrollSensitivity`), nhưng lưới con nằm trong card có `overflow: hidden` — cuộn ở đây đẩy khối
+    // con ra NGOÀI khung container rồi kẹt luôn ở đó.
+    disableScrollHorizontal: true,
+    disableScrollVertical: true,
+});
+/**
+ * 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ỡ.
+ * 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"]}