@tanstack/table-core 9.0.0-beta.46 → 9.0.0-beta.47

package/dist/fns/sortFns.cjs

@@ -8,55 +8,93 @@
 */
 const reSplitAlphaNumeric = /([0-9]+)/gm;
 /**
+* Builds a `SortFn` from a value-level comparator plus an optional
+* `resolveDataValue` normalizer.
+*
+* The `sort` comparator receives both rows' data values, each already passed
+* through `resolveDataValue` when one is defined. Keeping normalization in the
+* resolver means a variant of an existing sorting function only has to swap
+* the resolver, not re-implement the comparison.
+*
+* The definition is attached to the returned function, so a variant can be
+* created by spreading a built-in sorting function and overriding what
+* differs:
+*
+* ```ts
+* const stripDiacritics = (value: string) =>
+*   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+*
+* const alphanumericIgnoreDiacritics = constructSortFn({
+*   ...sortFn_alphanumeric,
+*   resolveDataValue: (value) =>
+*     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+* })
+* ```
+*/
+function constructSortFn(def) {
+	const sortFn = Object.assign((rowA, rowB, columnId) => {
+		let dataValueA = rowA.getValue(columnId);
+		let dataValueB = rowB.getValue(columnId);
+		const resolveDataValue = sortFn.resolveDataValue;
+		if (resolveDataValue) {
+			dataValueA = resolveDataValue(dataValueA);
+			dataValueB = resolveDataValue(dataValueB);
+		}
+		return sortFn.sort(dataValueA, dataValueB, rowA, rowB, columnId);
+	}, def);
+	return sortFn;
+}
+/**
 * Sorts rows with the built-in alphanumeric strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_alphanumeric = (rowA, rowB, columnId) => {
-	return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-};
+const sortFn_alphanumeric = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in alphanumeric case sensitive strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_alphanumericCaseSensitive = (rowA, rowB, columnId) => {
-	return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-};
+const sortFn_alphanumericCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in text strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_text = (rowA, rowB, columnId) => {
-	return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-};
+const sortFn_text = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in text case sensitive strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_textCaseSensitive = (rowA, rowB, columnId) => {
-	return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-};
+const sortFn_textCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in datetime strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_datetime = (rowA, rowB, columnId) => {
-	const a = toDateSortValue(rowA.getValue(columnId));
-	const b = toDateSortValue(rowB.getValue(columnId));
-	return a > b ? 1 : a < b ? -1 : 0;
-};
+const sortFn_datetime = constructSortFn({
+	resolveDataValue: (dataValue) => toDateSortValue(dataValue),
+	sort: (dataValueA, dataValueB) => dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0
+});
 /**
 * Sorts rows with the built-in basic strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_basic = (rowA, rowB, columnId) => {
-	return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
-};
+const sortFn_basic = constructSortFn({ sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB) });
 function compareBasic(a, b) {
 	return a === b ? 0 : a > b ? 1 : -1;
 }
@@ -156,7 +194,15 @@ function countRemainingChunks(str, start) {
 /**
 * The built-in sorting function registry.
 *
-* Pass this object to sorted row model creation or extend it with custom sorting functions.
+* Registering this full object opts out of tree-shaking: every built-in
+* sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+* functions you actually use and registering just those in the `sortFns`
+* slot, or passing them directly to the `sortFn` column option.
+*
+* @deprecated Import individual `sortFn_*` functions instead for a smaller
+* bundle. This export still works and is not going away in v9, but built-in
+* name resolution (including `sortFn: 'auto'`) only finds functions you
+* register yourself.
 */
 const sortFns = {
 	alphanumeric: sortFn_alphanumeric,
@@ -168,6 +214,7 @@ const sortFns = {
 };
 
 //#endregion
+exports.constructSortFn = constructSortFn;
 exports.reSplitAlphaNumeric = reSplitAlphaNumeric;
 exports.sortFn_alphanumeric = sortFn_alphanumeric;
 exports.sortFn_alphanumericCaseSensitive = sortFn_alphanumericCaseSensitive;

package/dist/fns/sortFns.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sortFns.cjs","names":[],"sources":["../../src/fns/sortFns.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  const a = toDateSortValue(rowA.getValue(columnId))\n  const b = toDateSortValue(rowB.getValue(columnId))\n\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  return a > b ? 1 : a < b ? -1 : 0\n}\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))\n}\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Pass this object to sorted row model creation or extend it with custom sorting functions.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}
+{"version":3,"file":"sortFns.cjs","names":[],"sources":["../../src/fns/sortFns.ts"],"sourcesContent":["import type {\n  CreatedSortFn,\n  SortFnDef,\n} from '../features/row-sorting/rowSortingFeature.types'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Builds a `SortFn` from a value-level comparator plus an optional\n * `resolveDataValue` normalizer.\n *\n * The `sort` comparator receives both rows' data values, each already passed\n * through `resolveDataValue` when one is defined. Keeping normalization in the\n * resolver means a variant of an existing sorting function only has to swap\n * the resolver, not re-implement the comparison.\n *\n * The definition is attached to the returned function, so a variant can be\n * created by spreading a built-in sorting function and overriding what\n * differs:\n *\n * ```ts\n * const stripDiacritics = (value: string) =>\n *   value.normalize('NFD').replace(/\\p{Diacritic}/gu, '')\n *\n * const alphanumericIgnoreDiacritics = constructSortFn({\n *   ...sortFn_alphanumeric,\n *   resolveDataValue: (value) =>\n *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),\n * })\n * ```\n */\nexport function constructSortFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {\n  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(\n    <TRowFeatures extends TableFeatures, TRowData extends RowData>(\n      rowA: Row<TRowFeatures, TRowData>,\n      rowB: Row<TRowFeatures, TRowData>,\n      columnId: string,\n    ): number => {\n      let dataValueA = rowA.getValue(columnId)\n      let dataValueB = rowB.getValue(columnId)\n      const resolveDataValue = sortFn.resolveDataValue\n      if (resolveDataValue) {\n        dataValueA = resolveDataValue(dataValueA)\n        dataValueB = resolveDataValue(dataValueB)\n      }\n      // The def's comparator is typed against the factory's TFeatures/TData;\n      // the caller's row generics are erased at this boundary.\n      return sortFn.sort(\n        dataValueA,\n        dataValueB,\n        rowA as any,\n        rowB as any,\n        columnId,\n      )\n    },\n    def,\n  )\n  return sortFn\n}\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = constructSortFn({\n  resolveDataValue: (dataValue) => toDateSortValue(dataValue),\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  sort: (dataValueA, dataValueB) =>\n    dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0,\n})\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = constructSortFn({\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Registering this full object opts out of tree-shaking: every built-in\n * sorting function ends up in your bundle. Prefer importing the `sortFn_*`\n * functions you actually use and registering just those in the `sortFns`\n * slot, or passing them directly to the `sortFn` column option.\n *\n * @deprecated Import individual `sortFn_*` functions instead for a smaller\n * bundle. This export still works and is not going away in v9, but built-in\n * name resolution (including `sortFn: 'auto'`) only finds functions you\n * register yourself.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}

package/dist/fns/sortFns.d.cts

@@ -1,5 +1,5 @@
 import { RowData } from "../types/type-utils.cjs";
-import { Row } from "../types/Row.cjs";
+import { CreatedSortFn, SortFnDef } from "../features/row-sorting/rowSortingFeature.types.cjs";
 import { TableFeatures } from "../types/TableFeatures.cjs";
 
 //#region src/fns/sortFns.d.ts
@@ -10,56 +10,89 @@ import { TableFeatures } from "../types/TableFeatures.cjs";
  * strings like `item2` before `item10`.
  */
 declare const reSplitAlphaNumeric: RegExp;
+/**
+ * Builds a `SortFn` from a value-level comparator plus an optional
+ * `resolveDataValue` normalizer.
+ *
+ * The `sort` comparator receives both rows' data values, each already passed
+ * through `resolveDataValue` when one is defined. Keeping normalization in the
+ * resolver means a variant of an existing sorting function only has to swap
+ * the resolver, not re-implement the comparison.
+ *
+ * The definition is attached to the returned function, so a variant can be
+ * created by spreading a built-in sorting function and overriding what
+ * differs:
+ *
+ * ```ts
+ * const stripDiacritics = (value: string) =>
+ *   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+ *
+ * const alphanumericIgnoreDiacritics = constructSortFn({
+ *   ...sortFn_alphanumeric,
+ *   resolveDataValue: (value) =>
+ *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+ * })
+ * ```
+ */
+declare function constructSortFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData>;
 /**
  * Sorts rows with the built-in alphanumeric strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_alphanumeric: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+declare const sortFn_alphanumeric: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in alphanumeric case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_alphanumericCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+declare const sortFn_alphanumericCaseSensitive: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in text strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_text: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_text: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in text case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_textCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_textCaseSensitive: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in datetime strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_datetime: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_datetime: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in basic strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_basic: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_basic: CreatedSortFn<any, any>;
 /**
  * The built-in sorting function registry.
  *
- * Pass this object to sorted row model creation or extend it with custom sorting functions.
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
  */
 declare const sortFns: {
-  alphanumeric: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-  alphanumericCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-  basic: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  datetime: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  text: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  textCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+  alphanumeric: CreatedSortFn<any, any>;
+  alphanumericCaseSensitive: CreatedSortFn<any, any>;
+  basic: CreatedSortFn<any, any>;
+  datetime: CreatedSortFn<any, any>;
+  text: CreatedSortFn<any, any>;
+  textCaseSensitive: CreatedSortFn<any, any>;
 };
 type BuiltInSortFn = keyof typeof sortFns;
 //#endregion
-export { BuiltInSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
+export { BuiltInSortFn, constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
 //# sourceMappingURL=sortFns.d.cts.map

package/dist/fns/sortFns.d.ts

@@ -1,5 +1,5 @@
 import { RowData } from "../types/type-utils.js";
-import { Row } from "../types/Row.js";
+import { CreatedSortFn, SortFnDef } from "../features/row-sorting/rowSortingFeature.types.js";
 import { TableFeatures } from "../types/TableFeatures.js";
 
 //#region src/fns/sortFns.d.ts
@@ -10,56 +10,89 @@ import { TableFeatures } from "../types/TableFeatures.js";
  * strings like `item2` before `item10`.
  */
 declare const reSplitAlphaNumeric: RegExp;
+/**
+ * Builds a `SortFn` from a value-level comparator plus an optional
+ * `resolveDataValue` normalizer.
+ *
+ * The `sort` comparator receives both rows' data values, each already passed
+ * through `resolveDataValue` when one is defined. Keeping normalization in the
+ * resolver means a variant of an existing sorting function only has to swap
+ * the resolver, not re-implement the comparison.
+ *
+ * The definition is attached to the returned function, so a variant can be
+ * created by spreading a built-in sorting function and overriding what
+ * differs:
+ *
+ * ```ts
+ * const stripDiacritics = (value: string) =>
+ *   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+ *
+ * const alphanumericIgnoreDiacritics = constructSortFn({
+ *   ...sortFn_alphanumeric,
+ *   resolveDataValue: (value) =>
+ *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+ * })
+ * ```
+ */
+declare function constructSortFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData>;
 /**
  * Sorts rows with the built-in alphanumeric strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_alphanumeric: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+declare const sortFn_alphanumeric: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in alphanumeric case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_alphanumericCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+declare const sortFn_alphanumericCaseSensitive: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in text strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_text: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_text: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in text case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_textCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_textCaseSensitive: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in datetime strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_datetime: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_datetime: CreatedSortFn<any, any>;
 /**
  * Sorts rows with the built-in basic strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-declare const sortFn_basic: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+declare const sortFn_basic: CreatedSortFn<any, any>;
 /**
  * The built-in sorting function registry.
  *
- * Pass this object to sorted row model creation or extend it with custom sorting functions.
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
  */
 declare const sortFns: {
-  alphanumeric: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-  alphanumericCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-  basic: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  datetime: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  text: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  textCaseSensitive: <TFeatures extends TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+  alphanumeric: CreatedSortFn<any, any>;
+  alphanumericCaseSensitive: CreatedSortFn<any, any>;
+  basic: CreatedSortFn<any, any>;
+  datetime: CreatedSortFn<any, any>;
+  text: CreatedSortFn<any, any>;
+  textCaseSensitive: CreatedSortFn<any, any>;
 };
 type BuiltInSortFn = keyof typeof sortFns;
 //#endregion
-export { BuiltInSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
+export { BuiltInSortFn, constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
 //# sourceMappingURL=sortFns.d.ts.map

package/dist/fns/sortFns.js

@@ -7,55 +7,93 @@
 */
 const reSplitAlphaNumeric = /([0-9]+)/gm;
 /**
+* Builds a `SortFn` from a value-level comparator plus an optional
+* `resolveDataValue` normalizer.
+*
+* The `sort` comparator receives both rows' data values, each already passed
+* through `resolveDataValue` when one is defined. Keeping normalization in the
+* resolver means a variant of an existing sorting function only has to swap
+* the resolver, not re-implement the comparison.
+*
+* The definition is attached to the returned function, so a variant can be
+* created by spreading a built-in sorting function and overriding what
+* differs:
+*
+* ```ts
+* const stripDiacritics = (value: string) =>
+*   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+*
+* const alphanumericIgnoreDiacritics = constructSortFn({
+*   ...sortFn_alphanumeric,
+*   resolveDataValue: (value) =>
+*     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+* })
+* ```
+*/
+function constructSortFn(def) {
+	const sortFn = Object.assign((rowA, rowB, columnId) => {
+		let dataValueA = rowA.getValue(columnId);
+		let dataValueB = rowB.getValue(columnId);
+		const resolveDataValue = sortFn.resolveDataValue;
+		if (resolveDataValue) {
+			dataValueA = resolveDataValue(dataValueA);
+			dataValueB = resolveDataValue(dataValueB);
+		}
+		return sortFn.sort(dataValueA, dataValueB, rowA, rowB, columnId);
+	}, def);
+	return sortFn;
+}
+/**
 * Sorts rows with the built-in alphanumeric strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_alphanumeric = (rowA, rowB, columnId) => {
-	return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-};
+const sortFn_alphanumeric = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in alphanumeric case sensitive strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_alphanumericCaseSensitive = (rowA, rowB, columnId) => {
-	return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-};
+const sortFn_alphanumericCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in text strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_text = (rowA, rowB, columnId) => {
-	return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-};
+const sortFn_text = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in text case sensitive strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_textCaseSensitive = (rowA, rowB, columnId) => {
-	return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-};
+const sortFn_textCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
 /**
 * Sorts rows with the built-in datetime strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_datetime = (rowA, rowB, columnId) => {
-	const a = toDateSortValue(rowA.getValue(columnId));
-	const b = toDateSortValue(rowB.getValue(columnId));
-	return a > b ? 1 : a < b ? -1 : 0;
-};
+const sortFn_datetime = constructSortFn({
+	resolveDataValue: (dataValue) => toDateSortValue(dataValue),
+	sort: (dataValueA, dataValueB) => dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0
+});
 /**
 * Sorts rows with the built-in basic strategy.
 *
 * This comparator returns ascending-order results; descending order is applied by the sorting row model.
 */
-const sortFn_basic = (rowA, rowB, columnId) => {
-	return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
-};
+const sortFn_basic = constructSortFn({ sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB) });
 function compareBasic(a, b) {
 	return a === b ? 0 : a > b ? 1 : -1;
 }
@@ -155,7 +193,15 @@ function countRemainingChunks(str, start) {
 /**
 * The built-in sorting function registry.
 *
-* Pass this object to sorted row model creation or extend it with custom sorting functions.
+* Registering this full object opts out of tree-shaking: every built-in
+* sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+* functions you actually use and registering just those in the `sortFns`
+* slot, or passing them directly to the `sortFn` column option.
+*
+* @deprecated Import individual `sortFn_*` functions instead for a smaller
+* bundle. This export still works and is not going away in v9, but built-in
+* name resolution (including `sortFn: 'auto'`) only finds functions you
+* register yourself.
 */
 const sortFns = {
 	alphanumeric: sortFn_alphanumeric,
@@ -167,5 +213,5 @@ const sortFns = {
 };
 
 //#endregion
-export { reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
+export { constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
 //# sourceMappingURL=sortFns.js.map

package/dist/fns/sortFns.js.map

@@ -1 +1 @@
-{"version":3,"file":"sortFns.js","names":[],"sources":["../../src/fns/sortFns.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  const a = toDateSortValue(rowA.getValue(columnId))\n  const b = toDateSortValue(rowB.getValue(columnId))\n\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  return a > b ? 1 : a < b ? -1 : 0\n}\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<TFeatures, TData>,\n  rowB: Row<TFeatures, TData>,\n  columnId: string,\n) => {\n  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))\n}\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Pass this object to sorted row model creation or extend it with custom sorting functions.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}
+{"version":3,"file":"sortFns.js","names":[],"sources":["../../src/fns/sortFns.ts"],"sourcesContent":["import type {\n  CreatedSortFn,\n  SortFnDef,\n} from '../features/row-sorting/rowSortingFeature.types'\nimport type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Builds a `SortFn` from a value-level comparator plus an optional\n * `resolveDataValue` normalizer.\n *\n * The `sort` comparator receives both rows' data values, each already passed\n * through `resolveDataValue` when one is defined. Keeping normalization in the\n * resolver means a variant of an existing sorting function only has to swap\n * the resolver, not re-implement the comparison.\n *\n * The definition is attached to the returned function, so a variant can be\n * created by spreading a built-in sorting function and overriding what\n * differs:\n *\n * ```ts\n * const stripDiacritics = (value: string) =>\n *   value.normalize('NFD').replace(/\\p{Diacritic}/gu, '')\n *\n * const alphanumericIgnoreDiacritics = constructSortFn({\n *   ...sortFn_alphanumeric,\n *   resolveDataValue: (value) =>\n *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),\n * })\n * ```\n */\nexport function constructSortFn<\n  TFeatures extends TableFeatures = any,\n  TData extends RowData = any,\n>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {\n  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(\n    <TRowFeatures extends TableFeatures, TRowData extends RowData>(\n      rowA: Row<TRowFeatures, TRowData>,\n      rowB: Row<TRowFeatures, TRowData>,\n      columnId: string,\n    ): number => {\n      let dataValueA = rowA.getValue(columnId)\n      let dataValueB = rowB.getValue(columnId)\n      const resolveDataValue = sortFn.resolveDataValue\n      if (resolveDataValue) {\n        dataValueA = resolveDataValue(dataValueA)\n        dataValueB = resolveDataValue(dataValueB)\n      }\n      // The def's comparator is typed against the factory's TFeatures/TData;\n      // the caller's row generics are erased at this boundary.\n      return sortFn.sort(\n        dataValueA,\n        dataValueB,\n        rowA as any,\n        rowB as any,\n        columnId,\n      )\n    },\n    def,\n  )\n  return sortFn\n}\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// The text sort is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive = constructSortFn({\n  resolveDataValue: (dataValue) => toString(dataValue),\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime = constructSortFn({\n  resolveDataValue: (dataValue) => toDateSortValue(dataValue),\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  sort: (dataValueA, dataValueB) =>\n    dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0,\n})\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic = constructSortFn({\n  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),\n})\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toDateSortValue(value: any) {\n  return value instanceof Date ? value.getTime() : value\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  let ai = 0\n  let bi = 0\n  const aLen = aStr.length\n  const bLen = bStr.length\n\n  while (ai < aLen && bi < bLen) {\n    const aIsNumeric = isDigit(aStr.charCodeAt(ai))\n    const bIsNumeric = isDigit(bStr.charCodeAt(bi))\n\n    const aEnd = findChunkEnd(aStr, ai, aIsNumeric)\n    const bEnd = findChunkEnd(bStr, bi, bIsNumeric)\n\n    // Both are string chunks\n    if (!aIsNumeric && !bIsNumeric) {\n      const stringComparison = compareStringChunks(\n        aStr,\n        ai,\n        aEnd,\n        bStr,\n        bi,\n        bEnd,\n      )\n      if (stringComparison) {\n        return stringComparison\n      }\n      ai = aEnd\n      bi = bEnd\n      continue\n    }\n\n    // One is a string chunk, one is a number chunk — the string sorts first\n    if (aIsNumeric !== bIsNumeric) {\n      return aIsNumeric ? 1 : -1\n    }\n\n    // Both are numeric chunks\n    const numericComparison = compareNumericChunks(\n      aStr,\n      ai,\n      aEnd,\n      bStr,\n      bi,\n      bEnd,\n    )\n    if (numericComparison) {\n      return numericComparison\n    }\n\n    ai = aEnd\n    bi = bEnd\n  }\n\n  // One side is exhausted — compare the counts of remaining non-empty chunks\n  return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi)\n}\n\nfunction isDigit(charCode: number) {\n  return charCode >= 48 && charCode <= 57\n}\n\nfunction findChunkEnd(str: string, start: number, isNumeric: boolean) {\n  let end = start + 1\n  while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) {\n    end++\n  }\n  return end\n}\n\nfunction compareStringChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  const aLength = aEnd - aStart\n  const bLength = bEnd - bStart\n  const minLength = aLength < bLength ? aLength : bLength\n\n  for (let i = 0; i < minLength; i++) {\n    const aCode = aStr.charCodeAt(aStart + i)\n    const bCode = bStr.charCodeAt(bStart + i)\n\n    if (aCode > bCode) {\n      return 1\n    }\n    if (bCode > aCode) {\n      return -1\n    }\n  }\n\n  if (aLength > bLength) {\n    return 1\n  }\n  if (bLength > aLength) {\n    return -1\n  }\n  return 0\n}\n\nfunction compareNumericChunks(\n  aStr: string,\n  aStart: number,\n  aEnd: number,\n  bStr: string,\n  bStart: number,\n  bEnd: number,\n) {\n  let aSignificantStart = aStart\n  while (\n    aSignificantStart < aEnd &&\n    aStr.charCodeAt(aSignificantStart) === 48\n  ) {\n    aSignificantStart++\n  }\n\n  let bSignificantStart = bStart\n  while (\n    bSignificantStart < bEnd &&\n    bStr.charCodeAt(bSignificantStart) === 48\n  ) {\n    bSignificantStart++\n  }\n\n  const aSignificantLength = aEnd - aSignificantStart\n  const bSignificantLength = bEnd - bSignificantStart\n\n  if (aSignificantLength === 0 && bSignificantLength === 0) {\n    return 0\n  }\n\n  if (aSignificantLength <= 15 && bSignificantLength <= 15) {\n    const an = parseSmallInt(aStr, aSignificantStart, aEnd)\n    const bn = parseSmallInt(bStr, bSignificantStart, bEnd)\n\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n    return 0\n  }\n\n  // Preserve parseInt precision-collapse behavior for unusually large chunks.\n  const an = parseInt(aStr.slice(aStart, aEnd), 10)\n  const bn = parseInt(bStr.slice(bStart, bEnd), 10)\n\n  if (an > bn) {\n    return 1\n  }\n  if (bn > an) {\n    return -1\n  }\n  return 0\n}\n\nfunction parseSmallInt(str: string, start: number, end: number) {\n  let result = 0\n  for (let i = start; i < end; i++) {\n    result = result * 10 + str.charCodeAt(i) - 48\n  }\n  return result\n}\n\nfunction countRemainingChunks(str: string, start: number) {\n  let count = 0\n  let index = start\n\n  while (index < str.length) {\n    count++\n    index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)))\n  }\n\n  return count\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Registering this full object opts out of tree-shaking: every built-in\n * sorting function ends up in your bundle. Prefer importing the `sortFn_*`\n * functions you actually use and registering just those in the `sortFns`\n * slot, or passing them directly to the `sortFn` column option.\n *\n * @deprecated Import individual `sortFn_*` functions instead for a smaller\n * bundle. This export still works and is not going away in v9, but built-in\n * name resolution (including `sortFn: 'auto'`) only finds functions you\n * register yourself.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":"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"}