@portnet/ui 6.0.1 → 6.0.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"_pickerSerialisation.js","names":["moment","coerceToDate","raw","outputFormat","Date","toDate","d","isNaN","getTime","undefined","parsed","isValid","serialiseDate","date","toISOString","format"],"sources":["../../../../src/lib/v2/patterns/_pickerSerialisation.ts"],"sourcesContent":["import moment from \"moment\";\r\n\r\n/**\r\n * _pickerSerialisation — lecture / ecriture partagees des ponts Formik de date.\r\n *\r\n * ── POURQUOI CE MODULE EXISTE ────────────────────────────────────────\r\n *\r\n * `FormikDatePicker` portait ces deux fonctions en prive. L'arrivee d'un\r\n * SECOND pont (`FormikDateTimePicker`, gap G-E) posait le choix : les recopier,\r\n * ou les partager.\r\n *\r\n * Les recopier aurait reproduit exactement la situation que la note S-03 de\r\n * `FormikDatePicker` raconte. Rappel de ce qu'elle dit : ce pont serialisait\r\n * VERS moment mais relisait DEPUIS `new Date(raw)`, en ignorant\r\n * `outputFormat`. L'asymetrie corrompait silencieusement tout format non ISO —\r\n * `new Date(\"31-12-2026\")` donne Invalid Date, `new Date(\"05-03-2026\")` donne\r\n * le 3 mai au lieu du 5 mars. Le chemin d'ECRITURE fonctionnait, donc un\r\n * formulaire rempli puis soumis se comportait correctement : le degat\r\n * n'apparaissait qu'a la RELECTURE, c'est-a-dire en modification. Un module a\r\n * livre ce defaut pendant sept lots sous un typecheck strict.\r\n *\r\n * Une asymetrie de ce genre entre DEUX ponts serait encore moins visible : ils\r\n * se ressemblent, personne ne les compare, et chacun a l'air correct\r\n * isolement. La seule garantie est qu'il n'y ait qu'un exemplaire du couple\r\n * lecture / ecriture.\r\n *\r\n * Module INTERNE : non exporte par la surface publique (prefixe `_`).\r\n */\r\n\r\n/**\r\n * Relit une valeur stockee par Formik vers un `Date`.\r\n *\r\n * `outputFormat` est passe pour que la lecture soit SYMETRIQUE de\r\n * `serialiseDate` : on parse avec le format qui a servi a ecrire, en mode\r\n * STRICT. Une valeur stockee qui ne correspond pas rend `null` plutot que la\r\n * meilleure approximation de moment — une date absente est recuperable, une\r\n * date fausse de deux mois ne l'est pas.\r\n */\r\nexport const coerceToDate = (\r\n  raw: unknown,\r\n  outputFormat?: string\r\n): Date | null => {\r\n  if (raw == null || raw === \"\") return null;\r\n  if (raw instanceof Date) return raw;\r\n  if (\r\n    typeof raw === \"object\" &&\r\n    typeof (raw as { toDate?: () => Date }).toDate === \"function\"\r\n  ) {\r\n    const d = (raw as { toDate: () => Date }).toDate();\r\n    return isNaN(d?.getTime?.()) ? null : d;\r\n  }\r\n  /* Garde sur `typeof raw === \"string\"` : un horodatage numerique garde le\r\n   * chemin `new Date(number)`, `moment(number, format)` n'ayant pas de sens.\r\n   * \"iso\" est exclu : ce n'est pas un jeton moment, et `new Date(isoString)`\r\n   * est deja correct. */\r\n  if (\r\n    typeof raw === \"string\" &&\r\n    outputFormat !== undefined &&\r\n    outputFormat !== \"iso\"\r\n  ) {\r\n    const parsed = moment(raw, outputFormat, true);\r\n    return parsed.isValid() ? parsed.toDate() : null;\r\n  }\r\n  const d = new Date(raw as string | number);\r\n  return isNaN(d.getTime()) ? null : d;\r\n};\r\n\r\n/**\r\n * Serialise un `Date` vers le format demande.\r\n *   undefined  -> rend le `Date` tel quel (defaut, compatible)\r\n *   \"iso\"      -> `Date.toISOString()`\r\n *   toute autre chaine -> `moment(date).format(outputFormat)`\r\n */\r\nexport function serialiseDate(\r\n  date: Date | null,\r\n  outputFormat: string | undefined\r\n): Date | string | null {\r\n  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {\r\n    return outputFormat ? \"\" : null;\r\n  }\r\n  if (!outputFormat) return date;\r\n  if (outputFormat === \"iso\") return date.toISOString();\r\n  return moment(date).format(outputFormat);\r\n}\r\n"],"mappings":"AAAA,OAAOA,MAAM,MAAM,QAAQ;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,YAAY,GAAGA,CAC1BC,GAAY,EACZC,YAAqB,KACL;EAChB,IAAID,GAAG,IAAI,IAAI,IAAIA,GAAG,KAAK,EAAE,EAAE,OAAO,IAAI;EAC1C,IAAIA,GAAG,YAAYE,IAAI,EAAE,OAAOF,GAAG;EACnC,IACE,OAAOA,GAAG,KAAK,QAAQ,IACvB,OAAQA,GAAG,CAA6BG,MAAM,KAAK,UAAU,EAC7D;IACA,MAAMC,CAAC,GAAIJ,GAAG,CAA4BG,MAAM,CAAC,CAAC;IAClD,OAAOE,KAAK,CAACD,CAAC,EAAEE,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,GAAGF,CAAC;EACzC;EACA;AACF;AACA;AACA;EACE,IACE,OAAOJ,GAAG,KAAK,QAAQ,IACvBC,YAAY,KAAKM,SAAS,IAC1BN,YAAY,KAAK,KAAK,EACtB;IACA,MAAMO,MAAM,GAAGV,MAAM,CAACE,GAAG,EAAEC,YAAY,EAAE,IAAI,CAAC;IAC9C,OAAOO,MAAM,CAACC,OAAO,CAAC,CAAC,GAAGD,MAAM,CAACL,MAAM,CAAC,CAAC,GAAG,IAAI;EAClD;EACA,MAAMC,CAAC,GAAG,IAAIF,IAAI,CAACF,GAAsB,CAAC;EAC1C,OAAOK,KAAK,CAACD,CAAC,CAACE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,GAAGF,CAAC;AACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,aAAaA,CAC3BC,IAAiB,EACjBV,YAAgC,EACV;EACtB,IAAI,CAACU,IAAI,IAAI,EAAEA,IAAI,YAAYT,IAAI,CAAC,IAAIG,KAAK,CAACM,IAAI,CAACL,OAAO,CAAC,CAAC,CAAC,EAAE;IAC7D,OAAOL,YAAY,GAAG,EAAE,GAAG,IAAI;EACjC;EACA,IAAI,CAACA,YAAY,EAAE,OAAOU,IAAI;EAC9B,IAAIV,YAAY,KAAK,KAAK,EAAE,OAAOU,IAAI,CAACC,WAAW,CAAC,CAAC;EACrD,OAAOd,MAAM,CAACa,IAAI,CAAC,CAACE,MAAM,CAACZ,YAAY,CAAC;AAC1C","ignoreList":[]}

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

@@ -1,10 +1,3 @@
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-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 _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 _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 _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; }
 /**
  * Internal: locale-correct multi-sort for DataGrid / useSortedRows.
  *
@@ -32,18 +25,18 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
  * "numeric: true" makes "Item 10" sort AFTER "Item 2" (natural order),
  * which the prior char-code comparison got backwards.
  */
-var COLLATOR_CACHE = new Map();
+const COLLATOR_CACHE = new Map();
 function getCollator(locale) {
-  var key = locale || "fr-FR";
-  var cached = COLLATOR_CACHE.get(key);
+  const key = locale || "fr-FR";
+  const cached = COLLATOR_CACHE.get(key);
   if (cached) return cached;
-  var collator;
+  let collator;
   try {
     collator = new Intl.Collator(key, {
       sensitivity: "accent",
       numeric: true
     });
-  } catch (_unused) {
+  } catch {
     // Invalid BCP-47 tag — fall back to fr-FR (matches the rest of v2's
     // graceful-locale-fallback contract from Batch 2).
     collator = new Intl.Collator("fr-FR", {
@@ -64,8 +57,8 @@ function getCollator(locale) {
  * applySort empty-string behaviour: "" < any non-empty string).
  */
 function compareValues(av, bv, collator) {
-  var aN = av == null || av === "";
-  var bN = bv == null || bv === "";
+  const aN = av == null || av === "";
+  const bN = bv == null || bv === "";
   if (aN && bN) return 0;
   if (aN) return -1;
   if (bN) return 1;
@@ -86,25 +79,16 @@ function compareValues(av, bv, collator) {
  * Returns a NEW sorted array (input is not mutated); the original array
  * reference is returned untouched when there is nothing to sort.
  */
-export function applySort(rows, sort) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  if (!(sort !== null && sort !== void 0 && sort.length)) return rows;
-  var collator = getCollator(options.locale);
-  return _toConsumableArray(rows).sort(function (a, b) {
-    var _iterator = _createForOfIteratorHelper(sort),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _step.value,
-          key = _step$value.key,
-          dir = _step$value.dir;
-        var cmp = compareValues(a[key], b[key], collator);
-        if (cmp !== 0) return dir === "asc" ? cmp : -cmp;
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+export function applySort(rows, sort, options = {}) {
+  if (!sort?.length) return rows;
+  const collator = getCollator(options.locale);
+  return [...rows].sort((a, b) => {
+    for (const {
+      key,
+      dir
+    } of sort) {
+      const cmp = compareValues(a[key], b[key], collator);
+      if (cmp !== 0) return dir === "asc" ? cmp : -cmp;
     }
     return 0;
   });

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

@@ -1 +1 @@
-{"version":3,"file":"_sort.js","names":["COLLATOR_CACHE","Map","getCollator","locale","key","cached","get","collator","Intl","Collator","sensitivity","numeric","_unused","set","compareValues","av","bv","aN","bN","Date","getTime","compare","String","applySort","rows","sort","options","arguments","length","undefined","_toConsumableArray","a","b","_iterator","_createForOfIteratorHelper","_step","s","n","done","_step$value","value","dir","cmp","err","e","f"],"sources":["../../../../src/lib/v2/patterns/_sort.ts"],"sourcesContent":["/**\r\n * Internal: locale-correct multi-sort for DataGrid / useSortedRows.\r\n *\r\n * Extracted verbatim from SortableHeader (Batch 12 / C1) so the sort logic can\r\n * be shared by the SortableHeader pattern (which re-exports `applySort`) and the\r\n * useSortedRows hook — without a hook → component import (a .ts hook importing a\r\n * still-.js component fails build:types under allowJs:false) and without\r\n * duplicating the collation logic. Behaviour is unchanged.\r\n *\r\n * NOT part of the public surface: `applySort` is re-exported from SortableHeader\r\n * (the public name / call site); getCollator + compareValues + the cache are\r\n * internal implementation details that were never exported.\r\n */\r\nimport type { SortDescriptor } from \"../types/common\";\r\nimport type { ApplySortOptions } from \"../types/datagrid\";\r\n\r\n/**\r\n * Module-level cache of Intl.Collator instances keyed by locale tag.\r\n * Collator construction allocates internal locale data (≈100 µs cold)\r\n * — caching matters for hosts that re-sort on every render.\r\n *\r\n * Using \"accent\" sensitivity preserves the prior toLowerCase-based\r\n * behaviour (case-insensitive) while honouring proper locale collation:\r\n *   - FR: É sorts as if E (between Élise and Étienne, not after Z).\r\n *   - AR: combining marks fold correctly.\r\n *   - DE: Umlauts (ä) sort with their base letter.\r\n * \"numeric: true\" makes \"Item 10\" sort AFTER \"Item 2\" (natural order),\r\n * which the prior char-code comparison got backwards.\r\n */\r\nconst COLLATOR_CACHE = new Map<string, Intl.Collator>();\r\n\r\nfunction getCollator(locale?: string): Intl.Collator {\r\n  const key = locale || \"fr-FR\";\r\n  const cached = COLLATOR_CACHE.get(key);\r\n  if (cached) return cached;\r\n  let collator: Intl.Collator;\r\n  try {\r\n    collator = new Intl.Collator(key, { sensitivity: \"accent\", numeric: true });\r\n  } catch {\r\n    // Invalid BCP-47 tag — fall back to fr-FR (matches the rest of v2's\r\n    // graceful-locale-fallback contract from Batch 2).\r\n    collator = new Intl.Collator(\"fr-FR\", { sensitivity: \"accent\", numeric: true });\r\n  }\r\n  COLLATOR_CACHE.set(key, collator);\r\n  return collator;\r\n}\r\n\r\n/**\r\n * Compare two cell values with locale-aware semantics. Routes through\r\n * the Collator only for strings or mixed types; numeric / Date pairs\r\n * use native operators (faster + exact).\r\n *\r\n * Null / undefined / empty-string sort FIRST (preserves the prior\r\n * applySort empty-string behaviour: \"\" < any non-empty string).\r\n */\r\nfunction compareValues(av: unknown, bv: unknown, collator: Intl.Collator): number {\r\n  const aN = av == null || av === \"\";\r\n  const bN = bv == null || bv === \"\";\r\n  if (aN && bN) return 0;\r\n  if (aN) return -1;\r\n  if (bN) return 1;\r\n\r\n  if (typeof av === \"number\" && typeof bv === \"number\") {\r\n    return av - bv;\r\n  }\r\n  if (av instanceof Date && bv instanceof Date) {\r\n    return av.getTime() - bv.getTime();\r\n  }\r\n  // String pair — or mixed types coerced to strings. The Collator handles\r\n  // both cases identically and respects `numeric: true` so digit runs\r\n  // inside a label compare numerically.\r\n  return collator.compare(String(av), String(bv));\r\n}\r\n\r\n/**\r\n * Pure helper — applies a multi-sort state to an array of rows.\r\n * Returns a NEW sorted array (input is not mutated); the original array\r\n * reference is returned untouched when there is nothing to sort.\r\n */\r\nexport function applySort<T extends object>(\r\n  rows: T[],\r\n  sort: readonly SortDescriptor[] | null | undefined,\r\n  options: ApplySortOptions = {},\r\n): T[] {\r\n  if (!sort?.length) return rows;\r\n  const collator = getCollator(options.locale);\r\n  return [...rows].sort((a, b) => {\r\n    for (const { key, dir } of sort) {\r\n      const cmp = compareValues(\r\n        (a as Record<string, unknown>)[key],\r\n        (b as Record<string, unknown>)[key],\r\n        collator,\r\n      );\r\n      if (cmp !== 0) return dir === \"asc\" ? cmp : -cmp;\r\n    }\r\n    return 0;\r\n  });\r\n}\r\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"_sort.js","names":["COLLATOR_CACHE","Map","getCollator","locale","key","cached","get","collator","Intl","Collator","sensitivity","numeric","set","compareValues","av","bv","aN","bN","Date","getTime","compare","String","applySort","rows","sort","options","length","a","b","dir","cmp"],"sources":["../../../../src/lib/v2/patterns/_sort.ts"],"sourcesContent":["/**\r\n * Internal: locale-correct multi-sort for DataGrid / useSortedRows.\r\n *\r\n * Extracted verbatim from SortableHeader (Batch 12 / C1) so the sort logic can\r\n * be shared by the SortableHeader pattern (which re-exports `applySort`) and the\r\n * useSortedRows hook — without a hook → component import (a .ts hook importing a\r\n * still-.js component fails build:types under allowJs:false) and without\r\n * duplicating the collation logic. Behaviour is unchanged.\r\n *\r\n * NOT part of the public surface: `applySort` is re-exported from SortableHeader\r\n * (the public name / call site); getCollator + compareValues + the cache are\r\n * internal implementation details that were never exported.\r\n */\r\nimport type { SortDescriptor } from \"../types/common\";\r\nimport type { ApplySortOptions } from \"../types/datagrid\";\r\n\r\n/**\r\n * Module-level cache of Intl.Collator instances keyed by locale tag.\r\n * Collator construction allocates internal locale data (≈100 µs cold)\r\n * — caching matters for hosts that re-sort on every render.\r\n *\r\n * Using \"accent\" sensitivity preserves the prior toLowerCase-based\r\n * behaviour (case-insensitive) while honouring proper locale collation:\r\n *   - FR: É sorts as if E (between Élise and Étienne, not after Z).\r\n *   - AR: combining marks fold correctly.\r\n *   - DE: Umlauts (ä) sort with their base letter.\r\n * \"numeric: true\" makes \"Item 10\" sort AFTER \"Item 2\" (natural order),\r\n * which the prior char-code comparison got backwards.\r\n */\r\nconst COLLATOR_CACHE = new Map<string, Intl.Collator>();\r\n\r\nfunction getCollator(locale?: string): Intl.Collator {\r\n  const key = locale || \"fr-FR\";\r\n  const cached = COLLATOR_CACHE.get(key);\r\n  if (cached) return cached;\r\n  let collator: Intl.Collator;\r\n  try {\r\n    collator = new Intl.Collator(key, { sensitivity: \"accent\", numeric: true });\r\n  } catch {\r\n    // Invalid BCP-47 tag — fall back to fr-FR (matches the rest of v2's\r\n    // graceful-locale-fallback contract from Batch 2).\r\n    collator = new Intl.Collator(\"fr-FR\", { sensitivity: \"accent\", numeric: true });\r\n  }\r\n  COLLATOR_CACHE.set(key, collator);\r\n  return collator;\r\n}\r\n\r\n/**\r\n * Compare two cell values with locale-aware semantics. Routes through\r\n * the Collator only for strings or mixed types; numeric / Date pairs\r\n * use native operators (faster + exact).\r\n *\r\n * Null / undefined / empty-string sort FIRST (preserves the prior\r\n * applySort empty-string behaviour: \"\" < any non-empty string).\r\n */\r\nfunction compareValues(av: unknown, bv: unknown, collator: Intl.Collator): number {\r\n  const aN = av == null || av === \"\";\r\n  const bN = bv == null || bv === \"\";\r\n  if (aN && bN) return 0;\r\n  if (aN) return -1;\r\n  if (bN) return 1;\r\n\r\n  if (typeof av === \"number\" && typeof bv === \"number\") {\r\n    return av - bv;\r\n  }\r\n  if (av instanceof Date && bv instanceof Date) {\r\n    return av.getTime() - bv.getTime();\r\n  }\r\n  // String pair — or mixed types coerced to strings. The Collator handles\r\n  // both cases identically and respects `numeric: true` so digit runs\r\n  // inside a label compare numerically.\r\n  return collator.compare(String(av), String(bv));\r\n}\r\n\r\n/**\r\n * Pure helper — applies a multi-sort state to an array of rows.\r\n * Returns a NEW sorted array (input is not mutated); the original array\r\n * reference is returned untouched when there is nothing to sort.\r\n */\r\nexport function applySort<T extends object>(\r\n  rows: T[],\r\n  sort: readonly SortDescriptor[] | null | undefined,\r\n  options: ApplySortOptions = {},\r\n): T[] {\r\n  if (!sort?.length) return rows;\r\n  const collator = getCollator(options.locale);\r\n  return [...rows].sort((a, b) => {\r\n    for (const { key, dir } of sort) {\r\n      const cmp = compareValues(\r\n        (a as Record<string, unknown>)[key],\r\n        (b as Record<string, unknown>)[key],\r\n        collator,\r\n      );\r\n      if (cmp !== 0) return dir === \"asc\" ? cmp : -cmp;\r\n    }\r\n    return 0;\r\n  });\r\n}\r\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,cAAc,GAAG,IAAIC,GAAG,CAAwB,CAAC;AAEvD,SAASC,WAAWA,CAACC,MAAe,EAAiB;EACnD,MAAMC,GAAG,GAAGD,MAAM,IAAI,OAAO;EAC7B,MAAME,MAAM,GAAGL,cAAc,CAACM,GAAG,CAACF,GAAG,CAAC;EACtC,IAAIC,MAAM,EAAE,OAAOA,MAAM;EACzB,IAAIE,QAAuB;EAC3B,IAAI;IACFA,QAAQ,GAAG,IAAIC,IAAI,CAACC,QAAQ,CAACL,GAAG,EAAE;MAAEM,WAAW,EAAE,QAAQ;MAAEC,OAAO,EAAE;IAAK,CAAC,CAAC;EAC7E,CAAC,CAAC,MAAM;IACN;IACA;IACAJ,QAAQ,GAAG,IAAIC,IAAI,CAACC,QAAQ,CAAC,OAAO,EAAE;MAAEC,WAAW,EAAE,QAAQ;MAAEC,OAAO,EAAE;IAAK,CAAC,CAAC;EACjF;EACAX,cAAc,CAACY,GAAG,CAACR,GAAG,EAAEG,QAAQ,CAAC;EACjC,OAAOA,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASM,aAAaA,CAACC,EAAW,EAAEC,EAAW,EAAER,QAAuB,EAAU;EAChF,MAAMS,EAAE,GAAGF,EAAE,IAAI,IAAI,IAAIA,EAAE,KAAK,EAAE;EAClC,MAAMG,EAAE,GAAGF,EAAE,IAAI,IAAI,IAAIA,EAAE,KAAK,EAAE;EAClC,IAAIC,EAAE,IAAIC,EAAE,EAAE,OAAO,CAAC;EACtB,IAAID,EAAE,EAAE,OAAO,CAAC,CAAC;EACjB,IAAIC,EAAE,EAAE,OAAO,CAAC;EAEhB,IAAI,OAAOH,EAAE,KAAK,QAAQ,IAAI,OAAOC,EAAE,KAAK,QAAQ,EAAE;IACpD,OAAOD,EAAE,GAAGC,EAAE;EAChB;EACA,IAAID,EAAE,YAAYI,IAAI,IAAIH,EAAE,YAAYG,IAAI,EAAE;IAC5C,OAAOJ,EAAE,CAACK,OAAO,CAAC,CAAC,GAAGJ,EAAE,CAACI,OAAO,CAAC,CAAC;EACpC;EACA;EACA;EACA;EACA,OAAOZ,QAAQ,CAACa,OAAO,CAACC,MAAM,CAACP,EAAE,CAAC,EAAEO,MAAM,CAACN,EAAE,CAAC,CAAC;AACjD;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASO,SAASA,CACvBC,IAAS,EACTC,IAAkD,EAClDC,OAAyB,GAAG,CAAC,CAAC,EACzB;EACL,IAAI,CAACD,IAAI,EAAEE,MAAM,EAAE,OAAOH,IAAI;EAC9B,MAAMhB,QAAQ,GAAGL,WAAW,CAACuB,OAAO,CAACtB,MAAM,CAAC;EAC5C,OAAO,CAAC,GAAGoB,IAAI,CAAC,CAACC,IAAI,CAAC,CAACG,CAAC,EAAEC,CAAC,KAAK;IAC9B,KAAK,MAAM;MAAExB,GAAG;MAAEyB;IAAI,CAAC,IAAIL,IAAI,EAAE;MAC/B,MAAMM,GAAG,GAAGjB,aAAa,CACtBc,CAAC,CAA6BvB,GAAG,CAAC,EAClCwB,CAAC,CAA6BxB,GAAG,CAAC,EACnCG,QACF,CAAC;MACD,IAAIuB,GAAG,KAAK,CAAC,EAAE,OAAOD,GAAG,KAAK,KAAK,GAAGC,GAAG,GAAG,CAACA,GAAG;IAClD;IACA,OAAO,CAAC;EACV,CAAC,CAAC;AACJ","ignoreList":[]}

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

@@ -1,19 +1,3 @@
-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";
 
 /**
@@ -58,200 +42,178 @@ import * as React from "react";
  * onDrop never fires.
  */
 
-export default function useColumnReorder(columns, columnOrder, onColumnOrderChange) {
-  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var resizeIsActive = options.resizeIsActive;
+export default function useColumnReorder(columns, columnOrder, onColumnOrderChange, options = {}) {
+  const {
+    resizeIsActive
+  } = options;
 
   // 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];
+  const effectiveOrder = React.useMemo(() => columnOrder || columns.map(c => c.key), [columnOrder, columns]);
+  const [dragKey, setDragKey] = React.useState(null);
+  const [overKey, setOverKey] = React.useState(null);
 
   // 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 () {
+  const dragKeyRef = React.useRef(null);
+  const reset = React.useCallback(() => {
     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.
+  const onDragStart = React.useCallback(key => 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();
-      try {
-        e.dataTransfer.dropEffect = "move";
-      } catch (_unused2) {
-        // Some browsers throw outside a trusted dragstart→drop chain.
-      }
-      if (overKey !== key) setOverKey(key);
-    };
+      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 {
+      // Older Safari throws on certain MIME types; ignored.
+    }
+  }, [resizeIsActive]);
+  const onDragOver = React.useCallback(key => e => {
+    // CRITICAL — without preventDefault, the browser refuses the
+    // drop and onDrop never fires.
+    e.preventDefault();
+    try {
+      e.dataTransfer.dropEffect = "move";
+    } catch {
+      // 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);
-    };
+  const onDragLeave = React.useCallback(key => () => {
+    // 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);
+  const onDrop = React.useCallback(targetKey => e => {
+    e.preventDefault();
+    const sourceKey = e.dataTransfer && e.dataTransfer.getData("text/plain") || dragKeyRef.current;
+    if (!sourceKey || sourceKey === targetKey) {
       reset();
-    };
+      return;
+    }
+    const sourceIdx = effectiveOrder.indexOf(sourceKey);
+    const targetIdx = effectiveOrder.indexOf(targetKey);
+    if (sourceIdx < 0 || targetIdx < 0) {
+      reset();
+      return;
+    }
+    const newOrder = [...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.
+    const insertIdx = newOrder.indexOf(targetKey);
+    newOrder.splice(insertIdx, 0, sourceKey);
+    if (onColumnOrderChange) onColumnOrderChange(newOrder);
+    reset();
   }, [effectiveOrder, onColumnOrderChange, reset]);
-  var onDragEnd = React.useCallback(function () {
+  const onDragEnd = React.useCallback(() => {
     // 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) {
+  const cellHandlers = React.useCallback(key => ({
+    draggable: true,
+    onDragStart: onDragStart(key),
+    onDragOver: onDragOver(key),
+    onDragLeave: onDragLeave(key),
+    onDrop: onDrop(key),
+    onDragEnd
+  }), [onDragStart, onDragOver, onDragLeave, onDrop, onDragEnd]);
+  const cellSx = React.useCallback(key => {
+    const isDragSource = dragKey === key;
+    const isDropTarget = overKey === key && dragKey !== key;
+    if (!isDragSource && !isDropTarget) return undefined;
     return {
-      draggable: true,
-      onDragStart: onDragStart(key),
-      onDragOver: onDragOver(key),
-      onDragLeave: onDragLeave(key),
-      onDrop: onDrop(key),
-      onDragEnd: onDragEnd
+      ...(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)"
+      })
     };
-  }, [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) {
+  const commitOrder = React.useCallback(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);
+  const swap = React.useCallback((key, dir) => {
+    const idx = effectiveOrder.indexOf(key);
     if (idx < 0) return;
-    var target = idx + dir;
+    const target = idx + dir;
     if (target < 0 || target >= effectiveOrder.length) return; // at edge
-    var newOrder = _toConsumableArray(effectiveOrder);
-    var a = newOrder[idx];
-    var b = newOrder[target];
+    const newOrder = [...effectiveOrder];
+    const a = newOrder[idx];
+    const 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]);
+  const moveEarlier = React.useCallback(key => swap(key, -1), [swap]);
+  const moveLater = React.useCallback(key => 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);
+  const moveToEdge = React.useCallback((key, edge) => {
+    const 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];
+    const newOrder = [...effectiveOrder];
+    const 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;
-      }
+  const handleKeyDown = React.useCallback(key => e => {
+    if (resizeIsActive) return;
+    const isLeft = e.key === "ArrowLeft";
+    const isRight = e.key === "ArrowRight";
+    const isHome = e.key === "Home";
+    const 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);
-    };
+    // RTL-aware physical-arrow mapping: in RTL the visual order is
+    // reversed, so ArrowLeft advances toward the end of the order.
+    const cell = e.currentTarget.closest("th");
+    const isRtl = !!cell && typeof window !== "undefined" && typeof window.getComputedStyle === "function" && window.getComputedStyle(cell).direction === "rtl";
+    const goLater = isRtl ? isLeft : isRight;
+    if (goLater) moveLater(key);else moveEarlier(key);
   }, [resizeIsActive, moveToEdge, moveEarlier, moveLater]);
   return {
-    cellHandlers: cellHandlers,
-    cellSx: cellSx,
+    cellHandlers,
+    cellSx,
     isReordering: dragKey != null,
-    moveEarlier: moveEarlier,
-    moveLater: moveLater,
-    handleKeyDown: handleKeyDown
+    moveEarlier,
+    moveLater,
+    handleKeyDown
   };
 }
 //# sourceMappingURL=_useColumnReorder.js.map

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

@@ -1 +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":[]}
+{"version":3,"file":"_useColumnReorder.js","names":["React","useColumnReorder","columns","columnOrder","onColumnOrderChange","options","resizeIsActive","effectiveOrder","useMemo","map","c","key","dragKey","setDragKey","useState","overKey","setOverKey","dragKeyRef","useRef","reset","useCallback","current","onDragStart","e","preventDefault","dataTransfer","effectAllowed","setData","onDragOver","dropEffect","onDragLeave","onDrop","targetKey","sourceKey","getData","sourceIdx","indexOf","targetIdx","newOrder","splice","insertIdx","onDragEnd","cellHandlers","draggable","cellSx","isDragSource","isDropTarget","undefined","opacity","boxShadow","commitOrder","swap","dir","idx","target","length","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":[]}