@portnet/ui 5.0.32 → 6.0.1

package/dist/esm/v2/patterns/_useColumnReorder.js

@@ -0,0 +1,257 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from "react";
+
+/**
+ * useColumnReorder — Portnet UI v2 (private)
+ *
+ * Internal hook for the DataGrid + DataGridVirtualized reorder
+ * feature. NOT exported from the patterns barrel.
+ *
+ *   const { cellHandlers, cellSx, isReordering, moveEarlier, moveLater, handleKeyDown } =
+ *     useColumnReorder(
+ *       columns,                 // for fallback order resolution
+ *       columnOrder,             // host-controlled Array<key> | undefined
+ *       onColumnOrderChange,     // host-controlled setter
+ *       { resizeIsActive }       // cross-hook signal from useColumnResize
+ *     );
+ *
+ * Drop semantics (pointer):
+ *   The dragged column is INSERTED AT the target column's position.
+ *   The remaining columns shift to accommodate. This is the standard
+ *   Linear / Asana / GitHub Projects UX — the user thinks "move
+ *   column X to where Y is", not "swap X and Y".
+ *
+ * Keyboard (DG-R1 / WCAG 2.1.1):
+ *   moveEarlier(key) / moveLater(key) swap the column with its neighbour
+ *   toward the start / end of the order (edge-safe, no-op at the ends).
+ *   handleKeyDown(key) is meant for a focusable reorder control in the
+ *   header: ArrowLeft/ArrowRight move the column (RTL-aware, so the motion
+ *   matches the physical arrow), Home/End send it to the first/last slot.
+ *   Every move commits immediately via onColumnOrderChange (no grab/drop
+ *   mode). Direction-neutral names (earlier/later = toward index 0 / end)
+ *   keep the API unambiguous under RTL; the physical-arrow mapping lives in
+ *   handleKeyDown.
+ *
+ * Visual feedback during drag:
+ *   - Dragged column header: opacity 0.5
+ *   - Drop target column header: 2px inset accent outline
+ *   These are returned via cellSx; the host applies them as sx
+ *   fragments on each `<th>`.
+ *
+ * onDragOver MUST e.preventDefault() to allow drop. This is the
+ * single most-forgotten step of HTML5 native drag — without it,
+ * onDrop never fires.
+ */
+
+export default function useColumnReorder(columns, columnOrder, onColumnOrderChange) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var resizeIsActive = options.resizeIsActive;
+
+  // Effective order = host order, or fallback to the natural columns
+  // sequence. Memoised on the input shapes; no allocation when both
+  // refs are stable.
+  var effectiveOrder = React.useMemo(function () {
+    return columnOrder || columns.map(function (c) {
+      return c.key;
+    });
+  }, [columnOrder, columns]);
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    dragKey = _React$useState2[0],
+    setDragKey = _React$useState2[1];
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    overKey = _React$useState4[0],
+    setOverKey = _React$useState4[1];
+
+  // Refs mirror state for use inside fresh-closure handlers
+  // (the onDragEnd inside cellHandlers needs the latest dragKey
+  // even if React hasn't yet re-rendered).
+  var dragKeyRef = React.useRef(null);
+  var reset = React.useCallback(function () {
+    dragKeyRef.current = null;
+    setDragKey(null);
+    setOverKey(null);
+  }, []);
+  var onDragStart = React.useCallback(function (key) {
+    return function (e) {
+      // Cross-hook: if resize is active, abort the drag. Resize fires
+      // first via mousedown; this handler runs later via dragstart.
+      if (resizeIsActive) {
+        e.preventDefault();
+        return;
+      }
+      dragKeyRef.current = key;
+      setDragKey(key);
+      // Mark the data transfer with the source key. Some browsers
+      // require a non-empty payload to allow drop (Firefox).
+      try {
+        e.dataTransfer.effectAllowed = "move";
+        e.dataTransfer.setData("text/plain", key);
+      } catch (_unused) {
+        // Older Safari throws on certain MIME types; ignored.
+      }
+    };
+  }, [resizeIsActive]);
+  var onDragOver = React.useCallback(function (key) {
+    return function (e) {
+      // CRITICAL — without preventDefault, the browser refuses the
+      // drop and onDrop never fires.
+      e.preventDefault();
+      try {
+        e.dataTransfer.dropEffect = "move";
+      } catch (_unused2) {
+        // Some browsers throw outside a trusted dragstart→drop chain.
+      }
+      if (overKey !== key) setOverKey(key);
+    };
+  }, [overKey]);
+  var onDragLeave = React.useCallback(function (key) {
+    return function () {
+      // Only clear when leaving the same key we'd entered. Without
+      // this guard, fast moves between cells flicker the highlight.
+      if (overKey === key) setOverKey(null);
+    };
+  }, [overKey]);
+  var onDrop = React.useCallback(function (targetKey) {
+    return function (e) {
+      e.preventDefault();
+      var sourceKey = e.dataTransfer && e.dataTransfer.getData("text/plain") || dragKeyRef.current;
+      if (!sourceKey || sourceKey === targetKey) {
+        reset();
+        return;
+      }
+      var sourceIdx = effectiveOrder.indexOf(sourceKey);
+      var targetIdx = effectiveOrder.indexOf(targetKey);
+      if (sourceIdx < 0 || targetIdx < 0) {
+        reset();
+        return;
+      }
+      var newOrder = _toConsumableArray(effectiveOrder);
+      newOrder.splice(sourceIdx, 1);
+      // After splice the target index may shift by 1 if source was
+      // before target. Recompute against the post-splice array.
+      var insertIdx = newOrder.indexOf(targetKey);
+      newOrder.splice(insertIdx, 0, sourceKey);
+      if (onColumnOrderChange) onColumnOrderChange(newOrder);
+      reset();
+    };
+  }, [effectiveOrder, onColumnOrderChange, reset]);
+  var onDragEnd = React.useCallback(function () {
+    // Fires whether the drop succeeded or the user cancelled (Esc /
+    // drop on a non-target). Belt-and-suspenders cleanup.
+    reset();
+  }, [reset]);
+  var cellHandlers = React.useCallback(function (key) {
+    return {
+      draggable: true,
+      onDragStart: onDragStart(key),
+      onDragOver: onDragOver(key),
+      onDragLeave: onDragLeave(key),
+      onDrop: onDrop(key),
+      onDragEnd: onDragEnd
+    };
+  }, [onDragStart, onDragOver, onDragLeave, onDrop, onDragEnd]);
+  var cellSx = React.useCallback(function (key) {
+    var isDragSource = dragKey === key;
+    var isDropTarget = overKey === key && dragKey !== key;
+    if (!isDragSource && !isDropTarget) return undefined;
+    return _objectSpread(_objectSpread({}, isDragSource && {
+      opacity: 0.5
+    }), isDropTarget && {
+      // Inset accent outline = "drop here" visual. boxShadow not
+      // outline so it doesn't extend beyond the cell border.
+      boxShadow: "inset 0 0 0 2px var(--accent)"
+    });
+  }, [dragKey, overKey]);
+
+  // ── Keyboard reorder (DG-R1) ───────────────────────────────────
+  // Commit a reordered copy of effectiveOrder. All keyboard moves route
+  // through here; edge/no-op cases are filtered by the callers.
+  var commitOrder = React.useCallback(function (newOrder) {
+    if (onColumnOrderChange) onColumnOrderChange(newOrder);
+  }, [onColumnOrderChange]);
+
+  // Adjacent swap toward the start (dir=-1) / end (dir=+1) of the order.
+  var swap = React.useCallback(function (key, dir) {
+    var idx = effectiveOrder.indexOf(key);
+    if (idx < 0) return;
+    var target = idx + dir;
+    if (target < 0 || target >= effectiveOrder.length) return; // at edge
+    var newOrder = _toConsumableArray(effectiveOrder);
+    var a = newOrder[idx];
+    var b = newOrder[target];
+    newOrder[idx] = b;
+    newOrder[target] = a;
+    commitOrder(newOrder);
+  }, [effectiveOrder, commitOrder]);
+  var moveEarlier = React.useCallback(function (key) {
+    return swap(key, -1);
+  }, [swap]);
+  var moveLater = React.useCallback(function (key) {
+    return swap(key, 1);
+  }, [swap]);
+
+  // Send the column to the first / last slot (Home / End).
+  var moveToEdge = React.useCallback(function (key, edge) {
+    var idx = effectiveOrder.indexOf(key);
+    if (idx < 0) return;
+    if (edge === "start" && idx === 0) return;
+    if (edge === "end" && idx === effectiveOrder.length - 1) return;
+    var newOrder = _toConsumableArray(effectiveOrder);
+    var moved = newOrder.splice(idx, 1)[0];
+    if (edge === "start") newOrder.unshift(moved);else newOrder.push(moved);
+    commitOrder(newOrder);
+  }, [effectiveOrder, commitOrder]);
+  var handleKeyDown = React.useCallback(function (key) {
+    return function (e) {
+      if (resizeIsActive) return;
+      var isLeft = e.key === "ArrowLeft";
+      var isRight = e.key === "ArrowRight";
+      var isHome = e.key === "Home";
+      var isEnd = e.key === "End";
+      if (!isLeft && !isRight && !isHome && !isEnd) return;
+      e.preventDefault();
+      e.stopPropagation();
+      if (isHome) {
+        moveToEdge(key, "start");
+        return;
+      }
+      if (isEnd) {
+        moveToEdge(key, "end");
+        return;
+      }
+
+      // RTL-aware physical-arrow mapping: in RTL the visual order is
+      // reversed, so ArrowLeft advances toward the end of the order.
+      var cell = e.currentTarget.closest("th");
+      var isRtl = !!cell && typeof window !== "undefined" && typeof window.getComputedStyle === "function" && window.getComputedStyle(cell).direction === "rtl";
+      var goLater = isRtl ? isLeft : isRight;
+      if (goLater) moveLater(key);else moveEarlier(key);
+    };
+  }, [resizeIsActive, moveToEdge, moveEarlier, moveLater]);
+  return {
+    cellHandlers: cellHandlers,
+    cellSx: cellSx,
+    isReordering: dragKey != null,
+    moveEarlier: moveEarlier,
+    moveLater: moveLater,
+    handleKeyDown: handleKeyDown
+  };
+}
+//# sourceMappingURL=_useColumnReorder.js.map

package/dist/esm/v2/patterns/_useColumnReorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_useColumnReorder.js","names":["React","useColumnReorder","columns","columnOrder","onColumnOrderChange","options","arguments","length","undefined","resizeIsActive","effectiveOrder","useMemo","map","c","key","_React$useState","useState","_React$useState2","_slicedToArray","dragKey","setDragKey","_React$useState3","_React$useState4","overKey","setOverKey","dragKeyRef","useRef","reset","useCallback","current","onDragStart","e","preventDefault","dataTransfer","effectAllowed","setData","_unused","onDragOver","dropEffect","_unused2","onDragLeave","onDrop","targetKey","sourceKey","getData","sourceIdx","indexOf","targetIdx","newOrder","_toConsumableArray","splice","insertIdx","onDragEnd","cellHandlers","draggable","cellSx","isDragSource","isDropTarget","_objectSpread","opacity","boxShadow","commitOrder","swap","dir","idx","target","a","b","moveEarlier","moveLater","moveToEdge","edge","moved","unshift","push","handleKeyDown","isLeft","isRight","isHome","isEnd","stopPropagation","cell","currentTarget","closest","isRtl","window","getComputedStyle","direction","goLater","isReordering"],"sources":["../../../../src/lib/v2/patterns/_useColumnReorder.ts"],"sourcesContent":["import * as React from \"react\";\r\nimport type { SxProps, Theme } from \"@mui/material/styles\";\r\n\r\n/**\r\n * useColumnReorder — Portnet UI v2 (private)\r\n *\r\n * Internal hook for the DataGrid + DataGridVirtualized reorder\r\n * feature. NOT exported from the patterns barrel.\r\n *\r\n *   const { cellHandlers, cellSx, isReordering, moveEarlier, moveLater, handleKeyDown } =\r\n *     useColumnReorder(\r\n *       columns,                 // for fallback order resolution\r\n *       columnOrder,             // host-controlled Array<key> | undefined\r\n *       onColumnOrderChange,     // host-controlled setter\r\n *       { resizeIsActive }       // cross-hook signal from useColumnResize\r\n *     );\r\n *\r\n * Drop semantics (pointer):\r\n *   The dragged column is INSERTED AT the target column's position.\r\n *   The remaining columns shift to accommodate. This is the standard\r\n *   Linear / Asana / GitHub Projects UX — the user thinks \"move\r\n *   column X to where Y is\", not \"swap X and Y\".\r\n *\r\n * Keyboard (DG-R1 / WCAG 2.1.1):\r\n *   moveEarlier(key) / moveLater(key) swap the column with its neighbour\r\n *   toward the start / end of the order (edge-safe, no-op at the ends).\r\n *   handleKeyDown(key) is meant for a focusable reorder control in the\r\n *   header: ArrowLeft/ArrowRight move the column (RTL-aware, so the motion\r\n *   matches the physical arrow), Home/End send it to the first/last slot.\r\n *   Every move commits immediately via onColumnOrderChange (no grab/drop\r\n *   mode). Direction-neutral names (earlier/later = toward index 0 / end)\r\n *   keep the API unambiguous under RTL; the physical-arrow mapping lives in\r\n *   handleKeyDown.\r\n *\r\n * Visual feedback during drag:\r\n *   - Dragged column header: opacity 0.5\r\n *   - Drop target column header: 2px inset accent outline\r\n *   These are returned via cellSx; the host applies them as sx\r\n *   fragments on each `<th>`.\r\n *\r\n * onDragOver MUST e.preventDefault() to allow drop. This is the\r\n * single most-forgotten step of HTML5 native drag — without it,\r\n * onDrop never fires.\r\n */\r\n\r\nexport interface UseColumnReorderOptions {\r\n  resizeIsActive?: boolean | undefined;\r\n}\r\n\r\nexport interface ColumnReorderCellHandlers {\r\n  draggable: boolean;\r\n  onDragStart: (e: React.DragEvent) => void;\r\n  onDragOver: (e: React.DragEvent) => void;\r\n  onDragLeave: () => void;\r\n  onDrop: (e: React.DragEvent) => void;\r\n  onDragEnd: () => void;\r\n}\r\n\r\nexport interface UseColumnReorderResult {\r\n  cellHandlers: (key: string) => ColumnReorderCellHandlers;\r\n  cellSx: (key: string) => SxProps<Theme> | undefined;\r\n  isReordering: boolean;\r\n  /** Move the column one slot toward the start of the order (edge-safe). */\r\n  moveEarlier: (key: string) => void;\r\n  /** Move the column one slot toward the end of the order (edge-safe). */\r\n  moveLater: (key: string) => void;\r\n  /** onKeyDown for a focusable reorder control: Arrow (RTL-aware) / Home / End. */\r\n  handleKeyDown: (key: string) => (e: React.KeyboardEvent) => void;\r\n}\r\n\r\nexport default function useColumnReorder(\r\n  columns: ReadonlyArray<{ key: string }>,\r\n  columnOrder: string[] | undefined,\r\n  onColumnOrderChange: ((order: string[]) => void) | undefined,\r\n  options: UseColumnReorderOptions = {}\r\n): UseColumnReorderResult {\r\n  const { resizeIsActive } = options;\r\n\r\n  // Effective order = host order, or fallback to the natural columns\r\n  // sequence. Memoised on the input shapes; no allocation when both\r\n  // refs are stable.\r\n  const effectiveOrder = React.useMemo(\r\n    () => columnOrder || columns.map((c) => c.key),\r\n    [columnOrder, columns]\r\n  );\r\n\r\n  const [dragKey, setDragKey] = React.useState<string | null>(null);\r\n  const [overKey, setOverKey] = React.useState<string | null>(null);\r\n\r\n  // Refs mirror state for use inside fresh-closure handlers\r\n  // (the onDragEnd inside cellHandlers needs the latest dragKey\r\n  // even if React hasn't yet re-rendered).\r\n  const dragKeyRef = React.useRef<string | null>(null);\r\n\r\n  const reset = React.useCallback(() => {\r\n    dragKeyRef.current = null;\r\n    setDragKey(null);\r\n    setOverKey(null);\r\n  }, []);\r\n\r\n  const onDragStart = React.useCallback(\r\n    (key: string) => (e: React.DragEvent) => {\r\n      // Cross-hook: if resize is active, abort the drag. Resize fires\r\n      // first via mousedown; this handler runs later via dragstart.\r\n      if (resizeIsActive) {\r\n        e.preventDefault();\r\n        return;\r\n      }\r\n      dragKeyRef.current = key;\r\n      setDragKey(key);\r\n      // Mark the data transfer with the source key. Some browsers\r\n      // require a non-empty payload to allow drop (Firefox).\r\n      try {\r\n        e.dataTransfer.effectAllowed = \"move\";\r\n        e.dataTransfer.setData(\"text/plain\", key);\r\n      } catch {\r\n        // Older Safari throws on certain MIME types; ignored.\r\n      }\r\n    },\r\n    [resizeIsActive]\r\n  );\r\n\r\n  const onDragOver = React.useCallback(\r\n    (key: string) => (e: React.DragEvent) => {\r\n      // CRITICAL — without preventDefault, the browser refuses the\r\n      // drop and onDrop never fires.\r\n      e.preventDefault();\r\n      try {\r\n        e.dataTransfer.dropEffect = \"move\";\r\n      } catch {\r\n        // Some browsers throw outside a trusted dragstart→drop chain.\r\n      }\r\n      if (overKey !== key) setOverKey(key);\r\n    },\r\n    [overKey]\r\n  );\r\n\r\n  const onDragLeave = React.useCallback(\r\n    (key: string) => () => {\r\n      // Only clear when leaving the same key we'd entered. Without\r\n      // this guard, fast moves between cells flicker the highlight.\r\n      if (overKey === key) setOverKey(null);\r\n    },\r\n    [overKey]\r\n  );\r\n\r\n  const onDrop = React.useCallback(\r\n    (targetKey: string) => (e: React.DragEvent) => {\r\n      e.preventDefault();\r\n      const sourceKey =\r\n        (e.dataTransfer && e.dataTransfer.getData(\"text/plain\")) ||\r\n        dragKeyRef.current;\r\n\r\n      if (!sourceKey || sourceKey === targetKey) {\r\n        reset();\r\n        return;\r\n      }\r\n\r\n      const sourceIdx = effectiveOrder.indexOf(sourceKey);\r\n      const targetIdx = effectiveOrder.indexOf(targetKey);\r\n      if (sourceIdx < 0 || targetIdx < 0) {\r\n        reset();\r\n        return;\r\n      }\r\n\r\n      const newOrder = [...effectiveOrder];\r\n      newOrder.splice(sourceIdx, 1);\r\n      // After splice the target index may shift by 1 if source was\r\n      // before target. Recompute against the post-splice array.\r\n      const insertIdx = newOrder.indexOf(targetKey);\r\n      newOrder.splice(insertIdx, 0, sourceKey);\r\n\r\n      if (onColumnOrderChange) onColumnOrderChange(newOrder);\r\n      reset();\r\n    },\r\n    [effectiveOrder, onColumnOrderChange, reset]\r\n  );\r\n\r\n  const onDragEnd = React.useCallback(() => {\r\n    // Fires whether the drop succeeded or the user cancelled (Esc /\r\n    // drop on a non-target). Belt-and-suspenders cleanup.\r\n    reset();\r\n  }, [reset]);\r\n\r\n  const cellHandlers = React.useCallback(\r\n    (key: string): ColumnReorderCellHandlers => ({\r\n      draggable: true,\r\n      onDragStart: onDragStart(key),\r\n      onDragOver:  onDragOver(key),\r\n      onDragLeave: onDragLeave(key),\r\n      onDrop:      onDrop(key),\r\n      onDragEnd,\r\n    }),\r\n    [onDragStart, onDragOver, onDragLeave, onDrop, onDragEnd]\r\n  );\r\n\r\n  const cellSx = React.useCallback(\r\n    (key: string): SxProps<Theme> | undefined => {\r\n      const isDragSource = dragKey === key;\r\n      const isDropTarget = overKey === key && dragKey !== key;\r\n      if (!isDragSource && !isDropTarget) return undefined;\r\n      return {\r\n        ...(isDragSource && { opacity: 0.5 }),\r\n        ...(isDropTarget && {\r\n          // Inset accent outline = \"drop here\" visual. boxShadow not\r\n          // outline so it doesn't extend beyond the cell border.\r\n          boxShadow: \"inset 0 0 0 2px var(--accent)\",\r\n        }),\r\n      };\r\n    },\r\n    [dragKey, overKey]\r\n  );\r\n\r\n  // ── Keyboard reorder (DG-R1) ───────────────────────────────────\r\n  // Commit a reordered copy of effectiveOrder. All keyboard moves route\r\n  // through here; edge/no-op cases are filtered by the callers.\r\n  const commitOrder = React.useCallback(\r\n    (newOrder: string[]) => {\r\n      if (onColumnOrderChange) onColumnOrderChange(newOrder);\r\n    },\r\n    [onColumnOrderChange]\r\n  );\r\n\r\n  // Adjacent swap toward the start (dir=-1) / end (dir=+1) of the order.\r\n  const swap = React.useCallback(\r\n    (key: string, dir: -1 | 1) => {\r\n      const idx = effectiveOrder.indexOf(key);\r\n      if (idx < 0) return;\r\n      const target = idx + dir;\r\n      if (target < 0 || target >= effectiveOrder.length) return; // at edge\r\n      const newOrder = [...effectiveOrder];\r\n      const a = newOrder[idx] as string;\r\n      const b = newOrder[target] as string;\r\n      newOrder[idx] = b;\r\n      newOrder[target] = a;\r\n      commitOrder(newOrder);\r\n    },\r\n    [effectiveOrder, commitOrder]\r\n  );\r\n\r\n  const moveEarlier = React.useCallback((key: string) => swap(key, -1), [swap]);\r\n  const moveLater = React.useCallback((key: string) => swap(key, 1), [swap]);\r\n\r\n  // Send the column to the first / last slot (Home / End).\r\n  const moveToEdge = React.useCallback(\r\n    (key: string, edge: \"start\" | \"end\") => {\r\n      const idx = effectiveOrder.indexOf(key);\r\n      if (idx < 0) return;\r\n      if (edge === \"start\" && idx === 0) return;\r\n      if (edge === \"end\" && idx === effectiveOrder.length - 1) return;\r\n      const newOrder = [...effectiveOrder];\r\n      const moved = newOrder.splice(idx, 1)[0] as string;\r\n      if (edge === \"start\") newOrder.unshift(moved);\r\n      else newOrder.push(moved);\r\n      commitOrder(newOrder);\r\n    },\r\n    [effectiveOrder, commitOrder]\r\n  );\r\n\r\n  const handleKeyDown = React.useCallback(\r\n    (key: string) => (e: React.KeyboardEvent) => {\r\n      if (resizeIsActive) return;\r\n      const isLeft = e.key === \"ArrowLeft\";\r\n      const isRight = e.key === \"ArrowRight\";\r\n      const isHome = e.key === \"Home\";\r\n      const isEnd = e.key === \"End\";\r\n      if (!isLeft && !isRight && !isHome && !isEnd) return;\r\n\r\n      e.preventDefault();\r\n      e.stopPropagation();\r\n\r\n      if (isHome) {\r\n        moveToEdge(key, \"start\");\r\n        return;\r\n      }\r\n      if (isEnd) {\r\n        moveToEdge(key, \"end\");\r\n        return;\r\n      }\r\n\r\n      // RTL-aware physical-arrow mapping: in RTL the visual order is\r\n      // reversed, so ArrowLeft advances toward the end of the order.\r\n      const cell = (e.currentTarget as HTMLElement).closest(\"th\");\r\n      const isRtl =\r\n        !!cell &&\r\n        typeof window !== \"undefined\" &&\r\n        typeof window.getComputedStyle === \"function\" &&\r\n        window.getComputedStyle(cell).direction === \"rtl\";\r\n\r\n      const goLater = isRtl ? isLeft : isRight;\r\n      if (goLater) moveLater(key);\r\n      else moveEarlier(key);\r\n    },\r\n    [resizeIsActive, moveToEdge, moveEarlier, moveLater]\r\n  );\r\n\r\n  return {\r\n    cellHandlers,\r\n    cellSx,\r\n    isReordering: dragKey != null,\r\n    moveEarlier,\r\n    moveLater,\r\n    handleKeyDown,\r\n  };\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/v2/patterns/_useColumnResize.js

@@ -0,0 +1,191 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from "react";
+
+/**
+ * useColumnResize — Portnet UI v2 (private)
+ *
+ * Internal hook for the DataGrid + DataGridVirtualized resize
+ * feature. NOT exported from the patterns barrel; underscore filename
+ * prefix is the convention.
+ *
+ *   const { handleMouseDown, handleKeyDown, liveWidths, isResizing, minWidth } =
+ *     useColumnResize(
+ *       columnWidths,            // controlled
+ *       onColumnWidthsChange,    // controlled
+ *       { minWidth: 50 }
+ *     );
+ *
+ * Behaviour (pointer):
+ *   - handleMouseDown(key) returns an onMouseDown handler. Attach to
+ *     the grip element on each `<th>` border.
+ *   - On mousedown: captures starting clientX + current width + the
+ *     direction of the cell's writing mode (LTR vs RTL). Sets
+ *     `isResizing = true` so callers (e.g. the reorder hook) can
+ *     short-circuit.
+ *   - On mousemove (window-bound): computes the resize delta
+ *     respecting RTL and updates a local "live" width via state.
+ *     Floors at `minWidth`.
+ *   - On mouseup (window-bound): commits the live width to the host
+ *     via `onColumnWidthsChange`. Clears all internal state.
+ *
+ * Behaviour (keyboard, DG-2 / WCAG 2.1.1):
+ *   - handleKeyDown(key) returns an onKeyDown handler for the SAME grip
+ *     (the grip is a focusable role="separator"). ArrowRight / ArrowLeft
+ *     nudge the width by KEYBOARD_STEP px, RTL-aware so the direction
+ *     matches a rightward drag; Home resets to `minWidth`. Each press
+ *     commits immediately via `onColumnWidthsChange` (no drag session).
+ *   - `minWidth` is returned so the separator can advertise aria-valuemin.
+ */
+
+/** Width delta (px) applied per Arrow key press in keyboard resize. */
+var KEYBOARD_STEP = 16;
+export default function useColumnResize(columnWidths, onColumnWidthsChange) {
+  var _options$minWidth;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var minWidth = (_options$minWidth = options.minWidth) !== null && _options$minWidth !== void 0 ? _options$minWidth : 50;
+
+  // React state for "draggingKey" + "liveWidth" drives the rendered
+  // width during drag. Refs carry the latest values across the
+  // mouseup closure (avoids the stale-closure bug).
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    draggingKey = _React$useState2[0],
+    setDraggingKey = _React$useState2[1];
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    liveWidth = _React$useState4[0],
+    setLiveWidth = _React$useState4[1];
+  var liveWidthRef = React.useRef(null);
+  var dragStateRef = React.useRef(null);
+
+  // Keep the latest columnWidths reference reachable from the
+  // mouseup closure without re-binding listeners on every prop
+  // change. Avoids tearing down + re-adding the window listeners
+  // on each parent re-render that ships a fresh widths object.
+  var columnWidthsRef = React.useRef(columnWidths);
+  React.useEffect(function () {
+    columnWidthsRef.current = columnWidths;
+  }, [columnWidths]);
+
+  // Shared RTL probe for a grip's owning <th>: -1 in RTL, 1 otherwise.
+  var cellDirection = function cellDirection(grip) {
+    var cell = grip.closest("th");
+    return cell && typeof window !== "undefined" && typeof window.getComputedStyle === "function" && window.getComputedStyle(cell).direction === "rtl" ? -1 : 1;
+  };
+  var handleMouseDown = React.useCallback(function (key) {
+    return function (e) {
+      var _ref;
+      // Block native browser drag (text selection, image drag, the
+      // ancestor `<th draggable>` if reorder is also on) and the
+      // sortable-header click that lives next door in the same `<th>`.
+      e.preventDefault();
+      e.stopPropagation();
+      var grip = e.currentTarget;
+      var cell = grip.closest("th");
+      if (!cell) return;
+
+      // RTL detection at the cell level — most accurate (a `dir`
+      // attribute may be set anywhere up the ancestor chain).
+      var direction = cellDirection(grip);
+
+      // Starting width: prefer the host-controlled value, fall back to
+      // the rendered offsetWidth for a column the host hasn't sized.
+      var currentWidth = (_ref = columnWidthsRef.current && columnWidthsRef.current[key]) !== null && _ref !== void 0 ? _ref : cell.offsetWidth;
+      dragStateRef.current = {
+        x: e.clientX,
+        width: currentWidth,
+        key: key,
+        direction: direction
+      };
+      liveWidthRef.current = currentWidth;
+      setLiveWidth(currentWidth);
+      setDraggingKey(key);
+    };
+  }, []);
+
+  // DG-2 — keyboard resize on the focusable grip. Commits immediately;
+  // no drag session / window listeners involved.
+  var handleKeyDown = React.useCallback(function (key) {
+    return function (e) {
+      var _ref2;
+      var isLeft = e.key === "ArrowLeft";
+      var isRight = e.key === "ArrowRight";
+      var isHome = e.key === "Home";
+      if (!isLeft && !isRight && !isHome) return;
+      e.preventDefault();
+      e.stopPropagation();
+      var grip = e.currentTarget;
+      var cell = grip.closest("th");
+      var direction = cellDirection(grip);
+      var current = (_ref2 = columnWidthsRef.current && columnWidthsRef.current[key]) !== null && _ref2 !== void 0 ? _ref2 : cell ? cell.offsetWidth : minWidth;
+
+      // RTL-aware so ArrowRight matches a rightward drag (which grows the
+      // column in LTR and shrinks it in RTL, the grip being on the
+      // inline-end edge).
+      var next = isHome ? minWidth : current + (isRight ? 1 : -1) * KEYBOARD_STEP * direction;
+      var clamped = Math.max(minWidth, Math.round(next));
+      if (onColumnWidthsChange) {
+        onColumnWidthsChange(_objectSpread(_objectSpread({}, columnWidthsRef.current || {}), {}, _defineProperty({}, key, clamped)));
+      }
+    };
+  }, [minWidth, onColumnWidthsChange]);
+  React.useEffect(function () {
+    if (!draggingKey) return undefined;
+    var onMove = function onMove(e) {
+      var start = dragStateRef.current;
+      if (!start) return;
+      var delta = (e.clientX - start.x) * start.direction;
+      var next = Math.max(minWidth, start.width + delta);
+      liveWidthRef.current = next;
+      setLiveWidth(next);
+    };
+    var onUp = function onUp() {
+      var _liveWidthRef$current;
+      var start = dragStateRef.current;
+      var finalWidth = (_liveWidthRef$current = liveWidthRef.current) !== null && _liveWidthRef$current !== void 0 ? _liveWidthRef$current : start ? start.width : null;
+      if (start && finalWidth != null && onColumnWidthsChange) {
+        onColumnWidthsChange(_objectSpread(_objectSpread({}, columnWidthsRef.current || {}), {}, _defineProperty({}, start.key, finalWidth)));
+      }
+      dragStateRef.current = null;
+      liveWidthRef.current = null;
+      setLiveWidth(null);
+      setDraggingKey(null);
+    };
+    window.addEventListener("mousemove", onMove);
+    window.addEventListener("mouseup", onUp);
+    return function () {
+      window.removeEventListener("mousemove", onMove);
+      window.removeEventListener("mouseup", onUp);
+    };
+    // onColumnWidthsChange is intentionally listed — re-creates the
+    // mouseup closure with the latest setter ref. minWidth is rare
+    // to change but listed for correctness.
+  }, [draggingKey, onColumnWidthsChange, minWidth]);
+
+  // Live widths map = host columnWidths with the in-flight drag value
+  // patched in. Memoised on [draggingKey, liveWidth, columnWidths] so
+  // the reference is stable when nothing is dragging.
+  var liveWidths = React.useMemo(function () {
+    if (!draggingKey || liveWidth == null) return columnWidths;
+    return _objectSpread(_objectSpread({}, columnWidths || {}), {}, _defineProperty({}, draggingKey, liveWidth));
+  }, [draggingKey, liveWidth, columnWidths]);
+  return {
+    handleMouseDown: handleMouseDown,
+    handleKeyDown: handleKeyDown,
+    liveWidths: liveWidths,
+    isResizing: draggingKey != null,
+    minWidth: minWidth
+  };
+}
+//# sourceMappingURL=_useColumnResize.js.map

package/dist/esm/v2/patterns/_useColumnResize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_useColumnResize.js","names":["React","KEYBOARD_STEP","useColumnResize","columnWidths","onColumnWidthsChange","_options$minWidth","options","arguments","length","undefined","minWidth","_React$useState","useState","_React$useState2","_slicedToArray","draggingKey","setDraggingKey","_React$useState3","_React$useState4","liveWidth","setLiveWidth","liveWidthRef","useRef","dragStateRef","columnWidthsRef","useEffect","current","cellDirection","grip","cell","closest","window","getComputedStyle","direction","handleMouseDown","useCallback","key","e","_ref","preventDefault","stopPropagation","currentTarget","currentWidth","offsetWidth","x","clientX","width","handleKeyDown","_ref2","isLeft","isRight","isHome","next","clamped","Math","max","round","_objectSpread","_defineProperty","onMove","start","delta","onUp","_liveWidthRef$current","finalWidth","addEventListener","removeEventListener","liveWidths","useMemo","isResizing"],"sources":["../../../../src/lib/v2/patterns/_useColumnResize.ts"],"sourcesContent":["import * as React from \"react\";\r\n\r\n/**\r\n * useColumnResize — Portnet UI v2 (private)\r\n *\r\n * Internal hook for the DataGrid + DataGridVirtualized resize\r\n * feature. NOT exported from the patterns barrel; underscore filename\r\n * prefix is the convention.\r\n *\r\n *   const { handleMouseDown, handleKeyDown, liveWidths, isResizing, minWidth } =\r\n *     useColumnResize(\r\n *       columnWidths,            // controlled\r\n *       onColumnWidthsChange,    // controlled\r\n *       { minWidth: 50 }\r\n *     );\r\n *\r\n * Behaviour (pointer):\r\n *   - handleMouseDown(key) returns an onMouseDown handler. Attach to\r\n *     the grip element on each `<th>` border.\r\n *   - On mousedown: captures starting clientX + current width + the\r\n *     direction of the cell's writing mode (LTR vs RTL). Sets\r\n *     `isResizing = true` so callers (e.g. the reorder hook) can\r\n *     short-circuit.\r\n *   - On mousemove (window-bound): computes the resize delta\r\n *     respecting RTL and updates a local \"live\" width via state.\r\n *     Floors at `minWidth`.\r\n *   - On mouseup (window-bound): commits the live width to the host\r\n *     via `onColumnWidthsChange`. Clears all internal state.\r\n *\r\n * Behaviour (keyboard, DG-2 / WCAG 2.1.1):\r\n *   - handleKeyDown(key) returns an onKeyDown handler for the SAME grip\r\n *     (the grip is a focusable role=\"separator\"). ArrowRight / ArrowLeft\r\n *     nudge the width by KEYBOARD_STEP px, RTL-aware so the direction\r\n *     matches a rightward drag; Home resets to `minWidth`. Each press\r\n *     commits immediately via `onColumnWidthsChange` (no drag session).\r\n *   - `minWidth` is returned so the separator can advertise aria-valuemin.\r\n */\r\n\r\nexport type ColumnWidths = Record<string, number>;\r\n\r\n/** Width delta (px) applied per Arrow key press in keyboard resize. */\r\nconst KEYBOARD_STEP = 16;\r\n\r\nexport interface UseColumnResizeOptions {\r\n  minWidth?: number | undefined;\r\n}\r\n\r\nexport interface UseColumnResizeResult {\r\n  handleMouseDown: (key: string) => (e: React.MouseEvent) => void;\r\n  handleKeyDown: (key: string) => (e: React.KeyboardEvent) => void;\r\n  liveWidths: ColumnWidths | undefined;\r\n  isResizing: boolean;\r\n  minWidth: number;\r\n}\r\n\r\ninterface DragState {\r\n  x: number;\r\n  width: number;\r\n  key: string;\r\n  direction: 1 | -1;\r\n}\r\n\r\nexport default function useColumnResize(\r\n  columnWidths: ColumnWidths | undefined,\r\n  onColumnWidthsChange: ((widths: ColumnWidths) => void) | undefined,\r\n  options: UseColumnResizeOptions = {}\r\n): UseColumnResizeResult {\r\n  const minWidth = options.minWidth ?? 50;\r\n\r\n  // React state for \"draggingKey\" + \"liveWidth\" drives the rendered\r\n  // width during drag. Refs carry the latest values across the\r\n  // mouseup closure (avoids the stale-closure bug).\r\n  const [draggingKey, setDraggingKey] = React.useState<string | null>(null);\r\n  const [liveWidth, setLiveWidth] = React.useState<number | null>(null);\r\n  const liveWidthRef = React.useRef<number | null>(null);\r\n  const dragStateRef = React.useRef<DragState | null>(null);\r\n\r\n  // Keep the latest columnWidths reference reachable from the\r\n  // mouseup closure without re-binding listeners on every prop\r\n  // change. Avoids tearing down + re-adding the window listeners\r\n  // on each parent re-render that ships a fresh widths object.\r\n  const columnWidthsRef = React.useRef<ColumnWidths | undefined>(columnWidths);\r\n  React.useEffect(() => {\r\n    columnWidthsRef.current = columnWidths;\r\n  }, [columnWidths]);\r\n\r\n  // Shared RTL probe for a grip's owning <th>: -1 in RTL, 1 otherwise.\r\n  const cellDirection = (grip: HTMLElement): 1 | -1 => {\r\n    const cell = grip.closest(\"th\");\r\n    return cell &&\r\n      typeof window !== \"undefined\" &&\r\n      typeof window.getComputedStyle === \"function\" &&\r\n      window.getComputedStyle(cell).direction === \"rtl\"\r\n      ? -1\r\n      : 1;\r\n  };\r\n\r\n  const handleMouseDown = React.useCallback((key: string) => (e: React.MouseEvent) => {\r\n    // Block native browser drag (text selection, image drag, the\r\n    // ancestor `<th draggable>` if reorder is also on) and the\r\n    // sortable-header click that lives next door in the same `<th>`.\r\n    e.preventDefault();\r\n    e.stopPropagation();\r\n\r\n    const grip = e.currentTarget as HTMLElement;\r\n    const cell = grip.closest(\"th\");\r\n    if (!cell) return;\r\n\r\n    // RTL detection at the cell level — most accurate (a `dir`\r\n    // attribute may be set anywhere up the ancestor chain).\r\n    const direction = cellDirection(grip);\r\n\r\n    // Starting width: prefer the host-controlled value, fall back to\r\n    // the rendered offsetWidth for a column the host hasn't sized.\r\n    const currentWidth =\r\n      (columnWidthsRef.current && columnWidthsRef.current[key]) ??\r\n      cell.offsetWidth;\r\n\r\n    dragStateRef.current = {\r\n      x: e.clientX,\r\n      width: currentWidth,\r\n      key,\r\n      direction,\r\n    };\r\n\r\n    liveWidthRef.current = currentWidth;\r\n    setLiveWidth(currentWidth);\r\n    setDraggingKey(key);\r\n  }, []);\r\n\r\n  // DG-2 — keyboard resize on the focusable grip. Commits immediately;\r\n  // no drag session / window listeners involved.\r\n  const handleKeyDown = React.useCallback(\r\n    (key: string) => (e: React.KeyboardEvent) => {\r\n      const isLeft = e.key === \"ArrowLeft\";\r\n      const isRight = e.key === \"ArrowRight\";\r\n      const isHome = e.key === \"Home\";\r\n      if (!isLeft && !isRight && !isHome) return;\r\n      e.preventDefault();\r\n      e.stopPropagation();\r\n\r\n      const grip = e.currentTarget as HTMLElement;\r\n      const cell = grip.closest(\"th\");\r\n      const direction = cellDirection(grip);\r\n\r\n      const current =\r\n        (columnWidthsRef.current && columnWidthsRef.current[key]) ??\r\n        (cell ? cell.offsetWidth : minWidth);\r\n\r\n      // RTL-aware so ArrowRight matches a rightward drag (which grows the\r\n      // column in LTR and shrinks it in RTL, the grip being on the\r\n      // inline-end edge).\r\n      const next = isHome\r\n        ? minWidth\r\n        : current + (isRight ? 1 : -1) * KEYBOARD_STEP * direction;\r\n\r\n      const clamped = Math.max(minWidth, Math.round(next));\r\n      if (onColumnWidthsChange) {\r\n        onColumnWidthsChange({ ...(columnWidthsRef.current || {}), [key]: clamped });\r\n      }\r\n    },\r\n    [minWidth, onColumnWidthsChange]\r\n  );\r\n\r\n  React.useEffect(() => {\r\n    if (!draggingKey) return undefined;\r\n\r\n    const onMove = (e: MouseEvent) => {\r\n      const start = dragStateRef.current;\r\n      if (!start) return;\r\n      const delta = (e.clientX - start.x) * start.direction;\r\n      const next = Math.max(minWidth, start.width + delta);\r\n      liveWidthRef.current = next;\r\n      setLiveWidth(next);\r\n    };\r\n\r\n    const onUp = () => {\r\n      const start = dragStateRef.current;\r\n      const finalWidth = liveWidthRef.current ?? (start ? start.width : null);\r\n      if (start && finalWidth != null && onColumnWidthsChange) {\r\n        onColumnWidthsChange({\r\n          ...(columnWidthsRef.current || {}),\r\n          [start.key]: finalWidth,\r\n        });\r\n      }\r\n      dragStateRef.current = null;\r\n      liveWidthRef.current = null;\r\n      setLiveWidth(null);\r\n      setDraggingKey(null);\r\n    };\r\n\r\n    window.addEventListener(\"mousemove\", onMove);\r\n    window.addEventListener(\"mouseup\", onUp);\r\n    return () => {\r\n      window.removeEventListener(\"mousemove\", onMove);\r\n      window.removeEventListener(\"mouseup\", onUp);\r\n    };\r\n    // onColumnWidthsChange is intentionally listed — re-creates the\r\n    // mouseup closure with the latest setter ref. minWidth is rare\r\n    // to change but listed for correctness.\r\n  }, [draggingKey, onColumnWidthsChange, minWidth]);\r\n\r\n  // Live widths map = host columnWidths with the in-flight drag value\r\n  // patched in. Memoised on [draggingKey, liveWidth, columnWidths] so\r\n  // the reference is stable when nothing is dragging.\r\n  const liveWidths = React.useMemo(() => {\r\n    if (!draggingKey || liveWidth == null) return columnWidths;\r\n    return { ...(columnWidths || {}), [draggingKey]: liveWidth };\r\n  }, [draggingKey, liveWidth, columnWidths]);\r\n\r\n  return {\r\n    handleMouseDown,\r\n    handleKeyDown,\r\n    liveWidths,\r\n    isResizing: draggingKey != null,\r\n    minWidth,\r\n  };\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/v2/patterns/index.js

@@ -0,0 +1,95 @@
+export { default as ActionBar } from "./ActionBar";
+export { default as BulkActionBar } from "./BulkActionBar";
+export { default as ColumnsToggle } from "./ColumnsToggle";
+export { default as FormSection } from "./FormSection";
+export { default as FormPageShell } from "./FormPageShell";
+export { default as FormErrorSummary } from "./FormErrorSummary";
+// R-FV.3 companion to FormErrorSummary (R-FV.2) — renders nothing, moves
+// focus to the first field in error after a failed submit. Adopt both.
+export { default as FormikErrorFocus } from "./FormikErrorFocus";
+export { default as PageContent } from "./PageContent";
+export { default as DataGrid, applySort } from "./DataGrid";
+export { default as DataGridVirtualized } from "./DataGridVirtualized";
+export { default as DataGridSettingsMenu } from "./DataGridSettingsMenu";
+export { default as DataGridToolbar } from "./DataGridToolbar";
+export { default as CollapsibleDataGrid } from "./CollapsibleDataGrid";
+export { default as SortableHeader, getAriaSort } from "./SortableHeader";
+export { default as NetworkErrorBanner } from "./NetworkErrorBanner";
+export { default as ReferentielField } from "./ReferentielField";
+/**
+ * ReferentielField configuration types — public typed surface.
+ *
+ * Same class of gap as Gap-TS-003 (component types), which was fixed for
+ * `./components` but never extended to `./patterns`: the VALUE above was
+ * exported while the types describing its own REQUIRED props were not.
+ * `columns` and `criteria` are mandatory-to-configure, so a consumer had no
+ * way to type them without either deep-importing
+ * `@portnet/ui/dist/v2/patterns/…` (fragile, bypasses the `exports` map) or
+ * declaring a local twin — which the Platform TypeScript Guidelines forbid
+ * ("Reusable types belong inside Shared UI Library … Never duplicate").
+ *
+ * `ReferentielSearchResult` and `ReferentielSearchParams` are deliberately
+ * NOT re-exported here: identically-named types are already surfaced from
+ * `./referentiel` (useReferentielSearch) and `./v2/models` respectively, and
+ * `src/lib/index.ts` star-exports all three barrels — a second named export of
+ * either identifier is a hard TS2308 ambiguity at the library root.
+ *
+ * Additive and type-only: no runtime change, no existing export altered.
+ */
+
+export { default as Tour } from "./Tour";
+export { default as KeyboardShortcutsHelp } from "./KeyboardShortcutsHelp";
+export { default as DeleteResourceConfirmDialog } from "./DeleteResourceConfirmDialog";
+
+// ── Personalization · Saved Filters framework (v2/personalization) ────────────
+// SaveFilterDialog is presentational; SavedFiltersMenu is connected to the
+// savedFilters capability via useSavedFilters.
+export { default as SaveFilterDialog } from "./SaveFilterDialog";
+export { default as SavedFiltersMenu } from "./SavedFiltersMenu";
+
+// ── Personalization · Favorites DataGrid integration (v2/personalization) ─────
+// makeFavoriteColumn builds an always-visible favorites column for v2.DataGrid;
+// FavoritesFilter is the all/favorites-only segmented control.
+export { default as makeFavoriteColumn } from "./FavoriteColumn";
+export { default as FavoritesFilter } from "./FavoritesFilter";
+// ── Formik bridges ────────────────────────────────────────────────────────────
+export { default as FormikInput } from "./FormikInput";
+export { default as FormikTextarea } from "./FormikTextarea";
+export { default as FormikSelect } from "./FormikSelect";
+export { default as FormikCombobox } from "./FormikCombobox";
+/**
+ * FormikCombobox props — public typed surface.
+ *
+ * SAME GAP-TS-003 CLASS as the ReferentielField note above. That fix covered
+ * `ReferentielField` and `FormikReferentielField` but was not extended to the
+ * other Formik bridges: the VALUE is exported while the type describing its props
+ * is not, so a consumer cannot write `Omit<FormikComboboxProps<T>, …>`.
+ *
+ * REQUESTED BY bmdav-fe (TypeScript migration, batch 6f). That module stores the
+ * OPTION OBJECT in Formik rather than a primitive key, because its payload mapper
+ * reads `values.typeDemande.id` and sends `delegationTraitement` as a whole
+ * object — so it cannot adopt the primitive-key model without changing the
+ * request body sent to bmdav-be. It contains the resulting variance in ONE local
+ * adapter (`ObjectValuedFormikCombobox`) rather than scattering assertions across
+ * call sites, and that adapter must restate this component's prop contract minus
+ * `getOptionValue`. The deep-import fallback is unavailable under
+ * `moduleResolution: "bundler"`, since the package `exports` map does not expose
+ * `dist/v2/patterns/*`.
+ *
+ * `ComboboxOptionValue` is deliberately NOT re-exported here — it is already
+ * surfaced from `./components` (Combobox), and a second named export at the
+ * library root would be a TS2308 ambiguity, exactly as recorded above for
+ * `ReferentielSearchResult` / `ReferentielSearchParams`.
+ *
+ * Additive and type-only: no runtime change, no existing export altered.
+ */
+
+export { default as FormikDatePicker } from "./FormikDatePicker";
+export { default as FormikFile } from "./FormikFile";
+export { default as FormikCheckboxGroup } from "./FormikCheckboxGroup";
+export { default as FormikReferentielField } from "./FormikReferentielField";
+/** Affichage valeur système — fond grisé, aucune interaction.
+ *  Utiliser à la place de FormikInput disabled pour les champs
+ *  auto-générés ou non modifiables par l'utilisateur. */
+export { default as FormikDisplay } from "../components/FormikDisplay";
+//# sourceMappingURL=index.js.map