@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.41

package/dist/features/row-sorting/createSortedRowModel.cjs

@@ -0,0 +1,85 @@
+const require_utils = require('../../utils.cjs');
+const require_rowPaginationFeature_utils = require('../row-pagination/rowPaginationFeature.utils.cjs');
+const require_rowSortingFeature_utils = require('./rowSortingFeature.utils.cjs');
+
+//#region src/features/row-sorting/createSortedRowModel.ts
+function createSortedRowModel(sortFns) {
+	return (_table) => {
+		const table = _table;
+		if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns;
+		return require_utils.tableMemo({
+			feature: "rowSortingFeature",
+			table,
+			fnName: "table.getSortedRowModel",
+			memoDeps: () => {
+				var _table$atoms$sorting;
+				return [(_table$atoms$sorting = table.atoms.sorting) === null || _table$atoms$sorting === void 0 ? void 0 : _table$atoms$sorting.get(), table.getPreSortedRowModel()];
+			},
+			fn: () => _createSortedRowModel(table),
+			onAfterUpdate: () => require_rowPaginationFeature_utils.table_autoResetPageIndex(table)
+		});
+	};
+}
+function _createSortedRowModel(table) {
+	var _table$atoms$sorting2;
+	const preSortedRowModel = table.getPreSortedRowModel();
+	const sorting = (_table$atoms$sorting2 = table.atoms.sorting) === null || _table$atoms$sorting2 === void 0 ? void 0 : _table$atoms$sorting2.get();
+	if (!preSortedRowModel.rows.length || !(sorting === null || sorting === void 0 ? void 0 : sorting.length)) return preSortedRowModel;
+	const sortedFlatRows = [];
+	const availableSorting = sorting.filter((sort) => require_rowSortingFeature_utils.column_getCanSort(table.getColumn(sort.id)));
+	const columnInfoById = {};
+	availableSorting.forEach((sortEntry) => {
+		const column = table.getColumn(sortEntry.id);
+		if (!column) return;
+		columnInfoById[sortEntry.id] = {
+			sortUndefined: column.columnDef.sortUndefined,
+			invertSorting: column.columnDef.invertSorting,
+			sortFn: require_rowSortingFeature_utils.column_getSortFn(column)
+		};
+	});
+	const sortData = (rows) => {
+		const sortedData = rows.map((row) => {
+			return Object.assign(Object.create(Object.getPrototypeOf(row)), row);
+		});
+		sortedData.sort((rowA, rowB) => {
+			for (const sortEntry of availableSorting) {
+				const columnInfo = columnInfoById[sortEntry.id];
+				const sortUndefined = columnInfo.sortUndefined;
+				const isDesc = sortEntry.desc;
+				let sortInt = 0;
+				if (sortUndefined) {
+					const aValue = rowA.getValue(sortEntry.id);
+					const bValue = rowB.getValue(sortEntry.id);
+					const aUndefined = aValue === void 0;
+					const bUndefined = bValue === void 0;
+					if (aUndefined || bUndefined) {
+						if (sortUndefined === "first") return aUndefined ? -1 : 1;
+						if (sortUndefined === "last") return aUndefined ? 1 : -1;
+						sortInt = aUndefined && bUndefined ? 0 : aUndefined ? sortUndefined : -sortUndefined;
+					}
+				}
+				if (sortInt === 0) sortInt = columnInfo.sortFn(rowA, rowB, sortEntry.id);
+				if (sortInt !== 0) {
+					if (isDesc) sortInt *= -1;
+					if (columnInfo.invertSorting) sortInt *= -1;
+					return sortInt;
+				}
+			}
+			return rowA.index - rowB.index;
+		});
+		sortedData.forEach((row) => {
+			sortedFlatRows.push(row);
+			if (row.subRows.length) row.subRows = sortData(row.subRows);
+		});
+		return sortedData;
+	};
+	return {
+		rows: sortData(preSortedRowModel.rows),
+		flatRows: sortedFlatRows,
+		rowsById: preSortedRowModel.rowsById
+	};
+}
+
+//#endregion
+exports.createSortedRowModel = createSortedRowModel;
+//# sourceMappingURL=createSortedRowModel.cjs.map

package/dist/features/row-sorting/createSortedRowModel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSortedRowModel.cjs","names":["tableMemo","table_autoResetPageIndex","column_getCanSort","column_getSortFn"],"sources":["../../../src/features/row-sorting/createSortedRowModel.ts"],"sourcesContent":["import { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'\nimport { column_getCanSort, column_getSortFn } from './rowSortingFeature.utils'\nimport type { Column_Internal } from '../../types/Column'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type { SortFn, SortFns } from './rowSortingFeature.types'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>,\n): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns\n    return tableMemo({\n      feature: 'rowSortingFeature',\n      table,\n      fnName: 'table.getSortedRowModel',\n      memoDeps: () => [\n        table.atoms.sorting?.get(),\n        table.getPreSortedRowModel(),\n      ],\n      fn: () => _createSortedRowModel(table),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const preSortedRowModel = table.getPreSortedRowModel()\n  const sorting = table.atoms.sorting?.get()\n\n  if (!preSortedRowModel.rows.length || !sorting?.length) {\n    return preSortedRowModel\n  }\n\n  const sortedFlatRows: Array<Row<TFeatures, TData>> = []\n\n  // Filter out sortings that correspond to non existing columns\n  const availableSorting = sorting.filter((sort) =>\n    column_getCanSort(\n      table.getColumn(sort.id) as Column_Internal<TFeatures, TData>,\n    ),\n  )\n\n  const columnInfoById: Record<\n    string,\n    {\n      sortUndefined?: false | -1 | 1 | 'first' | 'last'\n      invertSorting?: boolean\n      sortFn: SortFn<TFeatures, TData>\n    }\n  > = {}\n\n  availableSorting.forEach((sortEntry) => {\n    const column: Column_Internal<TFeatures, TData> | undefined =\n      table.getColumn(sortEntry.id)\n    if (!column) return\n\n    columnInfoById[sortEntry.id] = {\n      sortUndefined: column.columnDef.sortUndefined,\n      invertSorting: column.columnDef.invertSorting,\n      sortFn: column_getSortFn(column),\n    }\n  })\n\n  const sortData = (rows: Array<Row<TFeatures, TData>>) => {\n    // This will also perform a stable sorting using the row index\n    // if needed.\n    // Preserve prototype chain so methods like getValue() remain accessible\n    const sortedData = rows.map((row) => {\n      const cloned = Object.create(Object.getPrototypeOf(row))\n      return Object.assign(cloned, row)\n    })\n\n    sortedData.sort((rowA, rowB) => {\n      for (const sortEntry of availableSorting) {\n        const columnInfo = columnInfoById[sortEntry.id]!\n        const sortUndefined = columnInfo.sortUndefined\n        const isDesc = sortEntry.desc\n\n        let sortInt = 0\n\n        // All sorting ints should always return in ascending order\n        if (sortUndefined) {\n          const aValue = rowA.getValue(sortEntry.id)\n          const bValue = rowB.getValue(sortEntry.id)\n\n          const aUndefined = aValue === undefined\n          const bUndefined = bValue === undefined\n\n          if (aUndefined || bUndefined) {\n            if (sortUndefined === 'first') return aUndefined ? -1 : 1\n            if (sortUndefined === 'last') return aUndefined ? 1 : -1\n            sortInt =\n              aUndefined && bUndefined\n                ? 0\n                : aUndefined\n                  ? sortUndefined\n                  : -sortUndefined\n          }\n        }\n\n        if (sortInt === 0) {\n          sortInt = columnInfo.sortFn(rowA, rowB, sortEntry.id)\n        }\n\n        // If sorting is non-zero, take care of desc and inversion\n        if (sortInt !== 0) {\n          if (isDesc) {\n            sortInt *= -1\n          }\n\n          if (columnInfo.invertSorting) {\n            sortInt *= -1\n          }\n\n          return sortInt\n        }\n      }\n      return rowA.index - rowB.index\n    })\n\n    // If there are sub-rows, sort them\n    sortedData.forEach((row) => {\n      sortedFlatRows.push(row)\n      if (row.subRows.length) {\n        row.subRows = sortData(row.subRows)\n      }\n    })\n\n    return sortedData\n  }\n\n  return {\n    rows: sortData(preSortedRowModel.rows),\n    flatRows: sortedFlatRows,\n    rowsById: preSortedRowModel.rowsById,\n  }\n}\n"],"mappings":";;;;;AAWA,SAAgB,qBAId,SACsE;AACtE,SAAQ,WAAW;EACjB,MAAM,QAA0C;AAChD,MAAI,CAAC,MAAM,aAAa,QAAS,OAAM,aAAa,UAAU;AAC9D,SAAOA,wBAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB;;oCACd,MAAM,MAAM,qFAAS,KAAK,EAC1B,MAAM,sBAAsB,CAC7B;;GACD,UAAU,sBAAsB,MAAM;GACtC,qBAAqBC,4DAAyB,MAAM;GACrD,CAAC;;;AAIN,SAAS,sBAGP,OAAqE;;CACrE,MAAM,oBAAoB,MAAM,sBAAsB;CACtD,MAAM,mCAAU,MAAM,MAAM,uFAAS,KAAK;AAE1C,KAAI,CAAC,kBAAkB,KAAK,UAAU,oDAAC,QAAS,QAC9C,QAAO;CAGT,MAAM,iBAA+C,EAAE;CAGvD,MAAM,mBAAmB,QAAQ,QAAQ,SACvCC,kDACE,MAAM,UAAU,KAAK,GAAG,CACzB,CACF;CAED,MAAM,iBAOF,EAAE;AAEN,kBAAiB,SAAS,cAAc;EACtC,MAAM,SACJ,MAAM,UAAU,UAAU,GAAG;AAC/B,MAAI,CAAC,OAAQ;AAEb,iBAAe,UAAU,MAAM;GAC7B,eAAe,OAAO,UAAU;GAChC,eAAe,OAAO,UAAU;GAChC,QAAQC,iDAAiB,OAAO;GACjC;GACD;CAEF,MAAM,YAAY,SAAuC;EAIvD,MAAM,aAAa,KAAK,KAAK,QAAQ;AAEnC,UAAO,OAAO,OADC,OAAO,OAAO,OAAO,eAAe,IAAI,CAC5B,EAAE,IAAI;IACjC;AAEF,aAAW,MAAM,MAAM,SAAS;AAC9B,QAAK,MAAM,aAAa,kBAAkB;IACxC,MAAM,aAAa,eAAe,UAAU;IAC5C,MAAM,gBAAgB,WAAW;IACjC,MAAM,SAAS,UAAU;IAEzB,IAAI,UAAU;AAGd,QAAI,eAAe;KACjB,MAAM,SAAS,KAAK,SAAS,UAAU,GAAG;KAC1C,MAAM,SAAS,KAAK,SAAS,UAAU,GAAG;KAE1C,MAAM,aAAa,WAAW;KAC9B,MAAM,aAAa,WAAW;AAE9B,SAAI,cAAc,YAAY;AAC5B,UAAI,kBAAkB,QAAS,QAAO,aAAa,KAAK;AACxD,UAAI,kBAAkB,OAAQ,QAAO,aAAa,IAAI;AACtD,gBACE,cAAc,aACV,IACA,aACE,gBACA,CAAC;;;AAIb,QAAI,YAAY,EACd,WAAU,WAAW,OAAO,MAAM,MAAM,UAAU,GAAG;AAIvD,QAAI,YAAY,GAAG;AACjB,SAAI,OACF,YAAW;AAGb,SAAI,WAAW,cACb,YAAW;AAGb,YAAO;;;AAGX,UAAO,KAAK,QAAQ,KAAK;IACzB;AAGF,aAAW,SAAS,QAAQ;AAC1B,kBAAe,KAAK,IAAI;AACxB,OAAI,IAAI,QAAQ,OACd,KAAI,UAAU,SAAS,IAAI,QAAQ;IAErC;AAEF,SAAO;;AAGT,QAAO;EACL,MAAM,SAAS,kBAAkB,KAAK;EACtC,UAAU;EACV,UAAU,kBAAkB;EAC7B"}

package/dist/features/row-sorting/createSortedRowModel.d.cts

@@ -0,0 +1,11 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { SortFn, SortFns } from "./rowSortingFeature.types.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table } from "../../types/Table.cjs";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
+
+//#region src/features/row-sorting/createSortedRowModel.d.ts
+declare function createSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+//#endregion
+export { createSortedRowModel };
+//# sourceMappingURL=createSortedRowModel.d.cts.map

package/dist/features/row-sorting/createSortedRowModel.d.ts

@@ -0,0 +1,11 @@
+import { RowData } from "../../types/type-utils.js";
+import { SortFn, SortFns } from "./rowSortingFeature.types.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table } from "../../types/Table.js";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+
+//#region src/features/row-sorting/createSortedRowModel.d.ts
+declare function createSortedRowModel<TFeatures extends TableFeatures, TData extends RowData>(sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+//#endregion
+export { createSortedRowModel };
+//# sourceMappingURL=createSortedRowModel.d.ts.map

package/dist/features/row-sorting/createSortedRowModel.js

@@ -0,0 +1,85 @@
+import { tableMemo } from "../../utils.js";
+import { table_autoResetPageIndex } from "../row-pagination/rowPaginationFeature.utils.js";
+import { column_getCanSort, column_getSortFn } from "./rowSortingFeature.utils.js";
+
+//#region src/features/row-sorting/createSortedRowModel.ts
+function createSortedRowModel(sortFns) {
+	return (_table) => {
+		const table = _table;
+		if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns;
+		return tableMemo({
+			feature: "rowSortingFeature",
+			table,
+			fnName: "table.getSortedRowModel",
+			memoDeps: () => {
+				var _table$atoms$sorting;
+				return [(_table$atoms$sorting = table.atoms.sorting) === null || _table$atoms$sorting === void 0 ? void 0 : _table$atoms$sorting.get(), table.getPreSortedRowModel()];
+			},
+			fn: () => _createSortedRowModel(table),
+			onAfterUpdate: () => table_autoResetPageIndex(table)
+		});
+	};
+}
+function _createSortedRowModel(table) {
+	var _table$atoms$sorting2;
+	const preSortedRowModel = table.getPreSortedRowModel();
+	const sorting = (_table$atoms$sorting2 = table.atoms.sorting) === null || _table$atoms$sorting2 === void 0 ? void 0 : _table$atoms$sorting2.get();
+	if (!preSortedRowModel.rows.length || !(sorting === null || sorting === void 0 ? void 0 : sorting.length)) return preSortedRowModel;
+	const sortedFlatRows = [];
+	const availableSorting = sorting.filter((sort) => column_getCanSort(table.getColumn(sort.id)));
+	const columnInfoById = {};
+	availableSorting.forEach((sortEntry) => {
+		const column = table.getColumn(sortEntry.id);
+		if (!column) return;
+		columnInfoById[sortEntry.id] = {
+			sortUndefined: column.columnDef.sortUndefined,
+			invertSorting: column.columnDef.invertSorting,
+			sortFn: column_getSortFn(column)
+		};
+	});
+	const sortData = (rows) => {
+		const sortedData = rows.map((row) => {
+			return Object.assign(Object.create(Object.getPrototypeOf(row)), row);
+		});
+		sortedData.sort((rowA, rowB) => {
+			for (const sortEntry of availableSorting) {
+				const columnInfo = columnInfoById[sortEntry.id];
+				const sortUndefined = columnInfo.sortUndefined;
+				const isDesc = sortEntry.desc;
+				let sortInt = 0;
+				if (sortUndefined) {
+					const aValue = rowA.getValue(sortEntry.id);
+					const bValue = rowB.getValue(sortEntry.id);
+					const aUndefined = aValue === void 0;
+					const bUndefined = bValue === void 0;
+					if (aUndefined || bUndefined) {
+						if (sortUndefined === "first") return aUndefined ? -1 : 1;
+						if (sortUndefined === "last") return aUndefined ? 1 : -1;
+						sortInt = aUndefined && bUndefined ? 0 : aUndefined ? sortUndefined : -sortUndefined;
+					}
+				}
+				if (sortInt === 0) sortInt = columnInfo.sortFn(rowA, rowB, sortEntry.id);
+				if (sortInt !== 0) {
+					if (isDesc) sortInt *= -1;
+					if (columnInfo.invertSorting) sortInt *= -1;
+					return sortInt;
+				}
+			}
+			return rowA.index - rowB.index;
+		});
+		sortedData.forEach((row) => {
+			sortedFlatRows.push(row);
+			if (row.subRows.length) row.subRows = sortData(row.subRows);
+		});
+		return sortedData;
+	};
+	return {
+		rows: sortData(preSortedRowModel.rows),
+		flatRows: sortedFlatRows,
+		rowsById: preSortedRowModel.rowsById
+	};
+}
+
+//#endregion
+export { createSortedRowModel };
+//# sourceMappingURL=createSortedRowModel.js.map

package/dist/features/row-sorting/createSortedRowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSortedRowModel.js","names":[],"sources":["../../../src/features/row-sorting/createSortedRowModel.ts"],"sourcesContent":["import { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'\nimport { column_getCanSort, column_getSortFn } from './rowSortingFeature.utils'\nimport type { Column_Internal } from '../../types/Column'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type { SortFn, SortFns } from './rowSortingFeature.types'\nimport type { RowData } from '../../types/type-utils'\n\nexport function createSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>,\n): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    if (!table._rowModelFns.sortFns) table._rowModelFns.sortFns = sortFns\n    return tableMemo({\n      feature: 'rowSortingFeature',\n      table,\n      fnName: 'table.getSortedRowModel',\n      memoDeps: () => [\n        table.atoms.sorting?.get(),\n        table.getPreSortedRowModel(),\n      ],\n      fn: () => _createSortedRowModel(table),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  const preSortedRowModel = table.getPreSortedRowModel()\n  const sorting = table.atoms.sorting?.get()\n\n  if (!preSortedRowModel.rows.length || !sorting?.length) {\n    return preSortedRowModel\n  }\n\n  const sortedFlatRows: Array<Row<TFeatures, TData>> = []\n\n  // Filter out sortings that correspond to non existing columns\n  const availableSorting = sorting.filter((sort) =>\n    column_getCanSort(\n      table.getColumn(sort.id) as Column_Internal<TFeatures, TData>,\n    ),\n  )\n\n  const columnInfoById: Record<\n    string,\n    {\n      sortUndefined?: false | -1 | 1 | 'first' | 'last'\n      invertSorting?: boolean\n      sortFn: SortFn<TFeatures, TData>\n    }\n  > = {}\n\n  availableSorting.forEach((sortEntry) => {\n    const column: Column_Internal<TFeatures, TData> | undefined =\n      table.getColumn(sortEntry.id)\n    if (!column) return\n\n    columnInfoById[sortEntry.id] = {\n      sortUndefined: column.columnDef.sortUndefined,\n      invertSorting: column.columnDef.invertSorting,\n      sortFn: column_getSortFn(column),\n    }\n  })\n\n  const sortData = (rows: Array<Row<TFeatures, TData>>) => {\n    // This will also perform a stable sorting using the row index\n    // if needed.\n    // Preserve prototype chain so methods like getValue() remain accessible\n    const sortedData = rows.map((row) => {\n      const cloned = Object.create(Object.getPrototypeOf(row))\n      return Object.assign(cloned, row)\n    })\n\n    sortedData.sort((rowA, rowB) => {\n      for (const sortEntry of availableSorting) {\n        const columnInfo = columnInfoById[sortEntry.id]!\n        const sortUndefined = columnInfo.sortUndefined\n        const isDesc = sortEntry.desc\n\n        let sortInt = 0\n\n        // All sorting ints should always return in ascending order\n        if (sortUndefined) {\n          const aValue = rowA.getValue(sortEntry.id)\n          const bValue = rowB.getValue(sortEntry.id)\n\n          const aUndefined = aValue === undefined\n          const bUndefined = bValue === undefined\n\n          if (aUndefined || bUndefined) {\n            if (sortUndefined === 'first') return aUndefined ? -1 : 1\n            if (sortUndefined === 'last') return aUndefined ? 1 : -1\n            sortInt =\n              aUndefined && bUndefined\n                ? 0\n                : aUndefined\n                  ? sortUndefined\n                  : -sortUndefined\n          }\n        }\n\n        if (sortInt === 0) {\n          sortInt = columnInfo.sortFn(rowA, rowB, sortEntry.id)\n        }\n\n        // If sorting is non-zero, take care of desc and inversion\n        if (sortInt !== 0) {\n          if (isDesc) {\n            sortInt *= -1\n          }\n\n          if (columnInfo.invertSorting) {\n            sortInt *= -1\n          }\n\n          return sortInt\n        }\n      }\n      return rowA.index - rowB.index\n    })\n\n    // If there are sub-rows, sort them\n    sortedData.forEach((row) => {\n      sortedFlatRows.push(row)\n      if (row.subRows.length) {\n        row.subRows = sortData(row.subRows)\n      }\n    })\n\n    return sortedData\n  }\n\n  return {\n    rows: sortData(preSortedRowModel.rows),\n    flatRows: sortedFlatRows,\n    rowsById: preSortedRowModel.rowsById,\n  }\n}\n"],"mappings":";;;;;AAWA,SAAgB,qBAId,SACsE;AACtE,SAAQ,WAAW;EACjB,MAAM,QAA0C;AAChD,MAAI,CAAC,MAAM,aAAa,QAAS,OAAM,aAAa,UAAU;AAC9D,SAAO,UAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB;;oCACd,MAAM,MAAM,qFAAS,KAAK,EAC1B,MAAM,sBAAsB,CAC7B;;GACD,UAAU,sBAAsB,MAAM;GACtC,qBAAqB,yBAAyB,MAAM;GACrD,CAAC;;;AAIN,SAAS,sBAGP,OAAqE;;CACrE,MAAM,oBAAoB,MAAM,sBAAsB;CACtD,MAAM,mCAAU,MAAM,MAAM,uFAAS,KAAK;AAE1C,KAAI,CAAC,kBAAkB,KAAK,UAAU,oDAAC,QAAS,QAC9C,QAAO;CAGT,MAAM,iBAA+C,EAAE;CAGvD,MAAM,mBAAmB,QAAQ,QAAQ,SACvC,kBACE,MAAM,UAAU,KAAK,GAAG,CACzB,CACF;CAED,MAAM,iBAOF,EAAE;AAEN,kBAAiB,SAAS,cAAc;EACtC,MAAM,SACJ,MAAM,UAAU,UAAU,GAAG;AAC/B,MAAI,CAAC,OAAQ;AAEb,iBAAe,UAAU,MAAM;GAC7B,eAAe,OAAO,UAAU;GAChC,eAAe,OAAO,UAAU;GAChC,QAAQ,iBAAiB,OAAO;GACjC;GACD;CAEF,MAAM,YAAY,SAAuC;EAIvD,MAAM,aAAa,KAAK,KAAK,QAAQ;AAEnC,UAAO,OAAO,OADC,OAAO,OAAO,OAAO,eAAe,IAAI,CAC5B,EAAE,IAAI;IACjC;AAEF,aAAW,MAAM,MAAM,SAAS;AAC9B,QAAK,MAAM,aAAa,kBAAkB;IACxC,MAAM,aAAa,eAAe,UAAU;IAC5C,MAAM,gBAAgB,WAAW;IACjC,MAAM,SAAS,UAAU;IAEzB,IAAI,UAAU;AAGd,QAAI,eAAe;KACjB,MAAM,SAAS,KAAK,SAAS,UAAU,GAAG;KAC1C,MAAM,SAAS,KAAK,SAAS,UAAU,GAAG;KAE1C,MAAM,aAAa,WAAW;KAC9B,MAAM,aAAa,WAAW;AAE9B,SAAI,cAAc,YAAY;AAC5B,UAAI,kBAAkB,QAAS,QAAO,aAAa,KAAK;AACxD,UAAI,kBAAkB,OAAQ,QAAO,aAAa,IAAI;AACtD,gBACE,cAAc,aACV,IACA,aACE,gBACA,CAAC;;;AAIb,QAAI,YAAY,EACd,WAAU,WAAW,OAAO,MAAM,MAAM,UAAU,GAAG;AAIvD,QAAI,YAAY,GAAG;AACjB,SAAI,OACF,YAAW;AAGb,SAAI,WAAW,cACb,YAAW;AAGb,YAAO;;;AAGX,UAAO,KAAK,QAAQ,KAAK;IACzB;AAGF,aAAW,SAAS,QAAQ;AAC1B,kBAAe,KAAK,IAAI;AACxB,OAAI,IAAI,QAAQ,OACd,KAAI,UAAU,SAAS,IAAI,QAAQ;IAErC;AAEF,SAAO;;AAGT,QAAO;EACL,MAAM,SAAS,kBAAkB,KAAK;EACtC,UAAU;EACV,UAAU,kBAAkB;EAC7B"}

package/dist/features/row-sorting/rowSortingFeature.cjs

@@ -0,0 +1,59 @@
+const require_utils = require('../../utils.cjs');
+const require_rowSortingFeature_utils = require('./rowSortingFeature.utils.cjs');
+
+//#region src/features/row-sorting/rowSortingFeature.ts
+function constructRowSortingFeature() {
+	return {
+		getInitialState(initialState) {
+			return {
+				sorting: require_rowSortingFeature_utils.getDefaultSortingState(),
+				...initialState
+			};
+		},
+		getDefaultColumnDef() {
+			return {
+				sortFn: "auto",
+				sortUndefined: 1
+			};
+		},
+		getDefaultTableOptions(table) {
+			return {
+				onSortingChange: require_utils.makeStateUpdater("sorting", table),
+				isMultiSortEvent: (e) => {
+					return e.shiftKey;
+				}
+			};
+		},
+		assignColumnPrototype(prototype, table) {
+			require_utils.assignPrototypeAPIs("rowSortingFeature", prototype, table, {
+				"column.getAutoSortFn": { fn: (column) => require_rowSortingFeature_utils.column_getAutoSortFn(column) },
+				"column.getAutoSortDir": { fn: (column) => require_rowSortingFeature_utils.column_getAutoSortDir(column) },
+				column_getSortFn: { fn: (column) => require_rowSortingFeature_utils.column_getSortFn(column) },
+				column_toggleSorting: { fn: (column, desc, multi) => require_rowSortingFeature_utils.column_toggleSorting(column, desc, multi) },
+				column_getFirstSortDir: { fn: (column) => require_rowSortingFeature_utils.column_getFirstSortDir(column) },
+				column_getNextSortingOrder: { fn: (column, multi) => require_rowSortingFeature_utils.column_getNextSortingOrder(column, multi) },
+				column_getCanSort: { fn: (column) => require_rowSortingFeature_utils.column_getCanSort(column) },
+				column_getCanMultiSort: { fn: (column) => require_rowSortingFeature_utils.column_getCanMultiSort(column) },
+				column_getIsSorted: { fn: (column) => require_rowSortingFeature_utils.column_getIsSorted(column) },
+				column_getSortIndex: { fn: (column) => require_rowSortingFeature_utils.column_getSortIndex(column) },
+				column_clearSorting: { fn: (column) => require_rowSortingFeature_utils.column_clearSorting(column) },
+				column_getToggleSortingHandler: { fn: (column) => require_rowSortingFeature_utils.column_getToggleSortingHandler(column) }
+			});
+		},
+		constructTableAPIs(table) {
+			require_utils.assignTableAPIs("rowSortingFeature", table, {
+				table_setSorting: { fn: (updater) => require_rowSortingFeature_utils.table_setSorting(table, updater) },
+				table_resetSorting: { fn: (defaultState) => require_rowSortingFeature_utils.table_resetSorting(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The (Row) Sorting feature adds sorting state and APIs to the table and column objects.
+*/
+const rowSortingFeature = constructRowSortingFeature();
+
+//#endregion
+exports.constructRowSortingFeature = constructRowSortingFeature;
+exports.rowSortingFeature = rowSortingFeature;
+//# sourceMappingURL=rowSortingFeature.cjs.map

package/dist/features/row-sorting/rowSortingFeature.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowSortingFeature.cjs","names":["getDefaultSortingState","makeStateUpdater","column_getAutoSortFn","column_getAutoSortDir","column_getSortFn","column_toggleSorting","column_getFirstSortDir","column_getNextSortingOrder","column_getCanSort","column_getCanMultiSort","column_getIsSorted","column_getSortIndex","column_clearSorting","column_getToggleSortingHandler","table_setSorting","table_resetSorting"],"sources":["../../../src/features/row-sorting/rowSortingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_clearSorting,\n  column_getAutoSortDir,\n  column_getAutoSortFn,\n  column_getCanMultiSort,\n  column_getCanSort,\n  column_getFirstSortDir,\n  column_getIsSorted,\n  column_getNextSortingOrder,\n  column_getSortFn,\n  column_getSortIndex,\n  column_getToggleSortingHandler,\n  column_toggleSorting,\n  getDefaultSortingState,\n  table_resetSorting,\n  table_setSorting,\n} from './rowSortingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   CachedRowModel_Sorted,\n//   ColumnDef_RowSorting,\n//   Column_RowSorting,\n//   CreateRowModel_Sorted,\n//   RowModelFns_RowSorting,\n//   TableOptions_RowSorting,\n//   TableState_RowSorting,\n//   Table_RowSorting,\n// } from './rowSortingFeature.types'\n\nexport interface RowSortingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Sorted<TFeatures, TData>\n  // Column: Column_RowSorting<TFeatures, TData>\n  // ColumnDef: ColumnDef_RowSorting<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Sorted<TFeatures, TData>\n  // RowModelFns: RowModelFns_RowSorting<TFeatures, TData>\n  // Table: Table_RowSorting<TFeatures, TData>\n  // TableOptions: TableOptions_RowSorting\n  // TableState: TableState_RowSorting\n}\n\nexport function constructRowSortingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<RowSortingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState(initialState) {\n      return {\n        sorting: getDefaultSortingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultColumnDef() {\n      return {\n        sortFn: 'auto',\n        sortUndefined: 1,\n      }\n    },\n\n    getDefaultTableOptions(table) {\n      return {\n        onSortingChange: makeStateUpdater('sorting', table),\n        isMultiSortEvent: (e: unknown) => {\n          return (e as MouseEvent).shiftKey\n        },\n      }\n    },\n\n    assignColumnPrototype(prototype, table) {\n      assignPrototypeAPIs('rowSortingFeature', prototype, table, {\n        'column.getAutoSortFn': {\n          fn: (column) => column_getAutoSortFn(column),\n        },\n        'column.getAutoSortDir': {\n          fn: (column) => column_getAutoSortDir(column),\n        },\n        column_getSortFn: {\n          fn: (column) => column_getSortFn(column),\n        },\n        column_toggleSorting: {\n          fn: (column, desc, multi) =>\n            column_toggleSorting(column, desc, multi),\n        },\n        column_getFirstSortDir: {\n          fn: (column) => column_getFirstSortDir(column),\n        },\n        column_getNextSortingOrder: {\n          fn: (column, multi) => column_getNextSortingOrder(column, multi),\n        },\n        column_getCanSort: {\n          fn: (column) => column_getCanSort(column),\n        },\n        column_getCanMultiSort: {\n          fn: (column) => column_getCanMultiSort(column),\n        },\n        column_getIsSorted: {\n          fn: (column) => column_getIsSorted(column),\n        },\n        column_getSortIndex: {\n          fn: (column) => column_getSortIndex(column),\n        },\n        column_clearSorting: {\n          fn: (column) => column_clearSorting(column),\n        },\n        column_getToggleSortingHandler: {\n          fn: (column) => column_getToggleSortingHandler(column),\n        },\n      })\n    },\n\n    constructTableAPIs(table) {\n      assignTableAPIs('rowSortingFeature', table, {\n        table_setSorting: {\n          fn: (updater) => table_setSorting(table, updater),\n        },\n        table_resetSorting: {\n          fn: (defaultState) => table_resetSorting(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The (Row) Sorting feature adds sorting state and APIs to the table and column objects.\n */\nexport const rowSortingFeature = constructRowSortingFeature()\n"],"mappings":";;;;AAiDA,SAAgB,6BAGmD;AACjE,QAAO;EACL,gBAAgB,cAAc;AAC5B,UAAO;IACL,SAASA,wDAAwB;IACjC,GAAG;IACJ;;EAGH,sBAAsB;AACpB,UAAO;IACL,QAAQ;IACR,eAAe;IAChB;;EAGH,uBAAuB,OAAO;AAC5B,UAAO;IACL,iBAAiBC,+BAAiB,WAAW,MAAM;IACnD,mBAAmB,MAAe;AAChC,YAAQ,EAAiB;;IAE5B;;EAGH,sBAAsB,WAAW,OAAO;AACtC,qCAAoB,qBAAqB,WAAW,OAAO;IACzD,wBAAwB,EACtB,KAAK,WAAWC,qDAAqB,OAAO,EAC7C;IACD,yBAAyB,EACvB,KAAK,WAAWC,sDAAsB,OAAO,EAC9C;IACD,kBAAkB,EAChB,KAAK,WAAWC,iDAAiB,OAAO,EACzC;IACD,sBAAsB,EACpB,KAAK,QAAQ,MAAM,UACjBC,qDAAqB,QAAQ,MAAM,MAAM,EAC5C;IACD,wBAAwB,EACtB,KAAK,WAAWC,uDAAuB,OAAO,EAC/C;IACD,4BAA4B,EAC1B,KAAK,QAAQ,UAAUC,2DAA2B,QAAQ,MAAM,EACjE;IACD,mBAAmB,EACjB,KAAK,WAAWC,kDAAkB,OAAO,EAC1C;IACD,wBAAwB,EACtB,KAAK,WAAWC,uDAAuB,OAAO,EAC/C;IACD,oBAAoB,EAClB,KAAK,WAAWC,mDAAmB,OAAO,EAC3C;IACD,qBAAqB,EACnB,KAAK,WAAWC,oDAAoB,OAAO,EAC5C;IACD,qBAAqB,EACnB,KAAK,WAAWC,oDAAoB,OAAO,EAC5C;IACD,gCAAgC,EAC9B,KAAK,WAAWC,+DAA+B,OAAO,EACvD;IACF,CAAC;;EAGJ,mBAAmB,OAAO;AACxB,iCAAgB,qBAAqB,OAAO;IAC1C,kBAAkB,EAChB,KAAK,YAAYC,iDAAiB,OAAO,QAAQ,EAClD;IACD,oBAAoB,EAClB,KAAK,iBAAiBC,mDAAmB,OAAO,aAAa,EAC9D;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,oBAAoB,4BAA4B"}

package/dist/features/row-sorting/rowSortingFeature.d.cts

@@ -0,0 +1,13 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/features/row-sorting/rowSortingFeature.d.ts
+interface RowSortingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+declare function constructRowSortingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<RowSortingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The (Row) Sorting feature adds sorting state and APIs to the table and column objects.
+ */
+declare const rowSortingFeature: TableFeature<RowSortingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { RowSortingFeatureConstructors, constructRowSortingFeature, rowSortingFeature };
+//# sourceMappingURL=rowSortingFeature.d.cts.map

package/dist/features/row-sorting/rowSortingFeature.d.ts

@@ -0,0 +1,13 @@
+import { RowData } from "../../types/type-utils.js";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/features/row-sorting/rowSortingFeature.d.ts
+interface RowSortingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+declare function constructRowSortingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<RowSortingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The (Row) Sorting feature adds sorting state and APIs to the table and column objects.
+ */
+declare const rowSortingFeature: TableFeature<RowSortingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { RowSortingFeatureConstructors, constructRowSortingFeature, rowSortingFeature };
+//# sourceMappingURL=rowSortingFeature.d.ts.map

package/dist/features/row-sorting/rowSortingFeature.js

@@ -0,0 +1,58 @@
+import { assignPrototypeAPIs, assignTableAPIs, makeStateUpdater } from "../../utils.js";
+import { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_resetSorting, table_setSorting } from "./rowSortingFeature.utils.js";
+
+//#region src/features/row-sorting/rowSortingFeature.ts
+function constructRowSortingFeature() {
+	return {
+		getInitialState(initialState) {
+			return {
+				sorting: getDefaultSortingState(),
+				...initialState
+			};
+		},
+		getDefaultColumnDef() {
+			return {
+				sortFn: "auto",
+				sortUndefined: 1
+			};
+		},
+		getDefaultTableOptions(table) {
+			return {
+				onSortingChange: makeStateUpdater("sorting", table),
+				isMultiSortEvent: (e) => {
+					return e.shiftKey;
+				}
+			};
+		},
+		assignColumnPrototype(prototype, table) {
+			assignPrototypeAPIs("rowSortingFeature", prototype, table, {
+				"column.getAutoSortFn": { fn: (column) => column_getAutoSortFn(column) },
+				"column.getAutoSortDir": { fn: (column) => column_getAutoSortDir(column) },
+				column_getSortFn: { fn: (column) => column_getSortFn(column) },
+				column_toggleSorting: { fn: (column, desc, multi) => column_toggleSorting(column, desc, multi) },
+				column_getFirstSortDir: { fn: (column) => column_getFirstSortDir(column) },
+				column_getNextSortingOrder: { fn: (column, multi) => column_getNextSortingOrder(column, multi) },
+				column_getCanSort: { fn: (column) => column_getCanSort(column) },
+				column_getCanMultiSort: { fn: (column) => column_getCanMultiSort(column) },
+				column_getIsSorted: { fn: (column) => column_getIsSorted(column) },
+				column_getSortIndex: { fn: (column) => column_getSortIndex(column) },
+				column_clearSorting: { fn: (column) => column_clearSorting(column) },
+				column_getToggleSortingHandler: { fn: (column) => column_getToggleSortingHandler(column) }
+			});
+		},
+		constructTableAPIs(table) {
+			assignTableAPIs("rowSortingFeature", table, {
+				table_setSorting: { fn: (updater) => table_setSorting(table, updater) },
+				table_resetSorting: { fn: (defaultState) => table_resetSorting(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The (Row) Sorting feature adds sorting state and APIs to the table and column objects.
+*/
+const rowSortingFeature = constructRowSortingFeature();
+
+//#endregion
+export { constructRowSortingFeature, rowSortingFeature };
+//# sourceMappingURL=rowSortingFeature.js.map

package/dist/features/row-sorting/rowSortingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowSortingFeature.js","names":[],"sources":["../../../src/features/row-sorting/rowSortingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_clearSorting,\n  column_getAutoSortDir,\n  column_getAutoSortFn,\n  column_getCanMultiSort,\n  column_getCanSort,\n  column_getFirstSortDir,\n  column_getIsSorted,\n  column_getNextSortingOrder,\n  column_getSortFn,\n  column_getSortIndex,\n  column_getToggleSortingHandler,\n  column_toggleSorting,\n  getDefaultSortingState,\n  table_resetSorting,\n  table_setSorting,\n} from './rowSortingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   CachedRowModel_Sorted,\n//   ColumnDef_RowSorting,\n//   Column_RowSorting,\n//   CreateRowModel_Sorted,\n//   RowModelFns_RowSorting,\n//   TableOptions_RowSorting,\n//   TableState_RowSorting,\n//   Table_RowSorting,\n// } from './rowSortingFeature.types'\n\nexport interface RowSortingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // CachedRowModel: CachedRowModel_Sorted<TFeatures, TData>\n  // Column: Column_RowSorting<TFeatures, TData>\n  // ColumnDef: ColumnDef_RowSorting<TFeatures, TData>\n  // CreateRowModels: CreateRowModel_Sorted<TFeatures, TData>\n  // RowModelFns: RowModelFns_RowSorting<TFeatures, TData>\n  // Table: Table_RowSorting<TFeatures, TData>\n  // TableOptions: TableOptions_RowSorting\n  // TableState: TableState_RowSorting\n}\n\nexport function constructRowSortingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<RowSortingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState(initialState) {\n      return {\n        sorting: getDefaultSortingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultColumnDef() {\n      return {\n        sortFn: 'auto',\n        sortUndefined: 1,\n      }\n    },\n\n    getDefaultTableOptions(table) {\n      return {\n        onSortingChange: makeStateUpdater('sorting', table),\n        isMultiSortEvent: (e: unknown) => {\n          return (e as MouseEvent).shiftKey\n        },\n      }\n    },\n\n    assignColumnPrototype(prototype, table) {\n      assignPrototypeAPIs('rowSortingFeature', prototype, table, {\n        'column.getAutoSortFn': {\n          fn: (column) => column_getAutoSortFn(column),\n        },\n        'column.getAutoSortDir': {\n          fn: (column) => column_getAutoSortDir(column),\n        },\n        column_getSortFn: {\n          fn: (column) => column_getSortFn(column),\n        },\n        column_toggleSorting: {\n          fn: (column, desc, multi) =>\n            column_toggleSorting(column, desc, multi),\n        },\n        column_getFirstSortDir: {\n          fn: (column) => column_getFirstSortDir(column),\n        },\n        column_getNextSortingOrder: {\n          fn: (column, multi) => column_getNextSortingOrder(column, multi),\n        },\n        column_getCanSort: {\n          fn: (column) => column_getCanSort(column),\n        },\n        column_getCanMultiSort: {\n          fn: (column) => column_getCanMultiSort(column),\n        },\n        column_getIsSorted: {\n          fn: (column) => column_getIsSorted(column),\n        },\n        column_getSortIndex: {\n          fn: (column) => column_getSortIndex(column),\n        },\n        column_clearSorting: {\n          fn: (column) => column_clearSorting(column),\n        },\n        column_getToggleSortingHandler: {\n          fn: (column) => column_getToggleSortingHandler(column),\n        },\n      })\n    },\n\n    constructTableAPIs(table) {\n      assignTableAPIs('rowSortingFeature', table, {\n        table_setSorting: {\n          fn: (updater) => table_setSorting(table, updater),\n        },\n        table_resetSorting: {\n          fn: (defaultState) => table_resetSorting(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The (Row) Sorting feature adds sorting state and APIs to the table and column objects.\n */\nexport const rowSortingFeature = constructRowSortingFeature()\n"],"mappings":";;;;AAiDA,SAAgB,6BAGmD;AACjE,QAAO;EACL,gBAAgB,cAAc;AAC5B,UAAO;IACL,SAAS,wBAAwB;IACjC,GAAG;IACJ;;EAGH,sBAAsB;AACpB,UAAO;IACL,QAAQ;IACR,eAAe;IAChB;;EAGH,uBAAuB,OAAO;AAC5B,UAAO;IACL,iBAAiB,iBAAiB,WAAW,MAAM;IACnD,mBAAmB,MAAe;AAChC,YAAQ,EAAiB;;IAE5B;;EAGH,sBAAsB,WAAW,OAAO;AACtC,uBAAoB,qBAAqB,WAAW,OAAO;IACzD,wBAAwB,EACtB,KAAK,WAAW,qBAAqB,OAAO,EAC7C;IACD,yBAAyB,EACvB,KAAK,WAAW,sBAAsB,OAAO,EAC9C;IACD,kBAAkB,EAChB,KAAK,WAAW,iBAAiB,OAAO,EACzC;IACD,sBAAsB,EACpB,KAAK,QAAQ,MAAM,UACjB,qBAAqB,QAAQ,MAAM,MAAM,EAC5C;IACD,wBAAwB,EACtB,KAAK,WAAW,uBAAuB,OAAO,EAC/C;IACD,4BAA4B,EAC1B,KAAK,QAAQ,UAAU,2BAA2B,QAAQ,MAAM,EACjE;IACD,mBAAmB,EACjB,KAAK,WAAW,kBAAkB,OAAO,EAC1C;IACD,wBAAwB,EACtB,KAAK,WAAW,uBAAuB,OAAO,EAC/C;IACD,oBAAoB,EAClB,KAAK,WAAW,mBAAmB,OAAO,EAC3C;IACD,qBAAqB,EACnB,KAAK,WAAW,oBAAoB,OAAO,EAC5C;IACD,qBAAqB,EACnB,KAAK,WAAW,oBAAoB,OAAO,EAC5C;IACD,gCAAgC,EAC9B,KAAK,WAAW,+BAA+B,OAAO,EACvD;IACF,CAAC;;EAGJ,mBAAmB,OAAO;AACxB,mBAAgB,qBAAqB,OAAO;IAC1C,kBAAkB,EAChB,KAAK,YAAY,iBAAiB,OAAO,QAAQ,EAClD;IACD,oBAAoB,EAClB,KAAK,iBAAiB,mBAAmB,OAAO,aAAa,EAC9D;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,oBAAoB,4BAA4B"}

package/dist/features/row-sorting/rowSortingFeature.types.d.cts

@@ -0,0 +1,182 @@
+import { OnChangeFn, RowData, Updater } from "../../types/type-utils.cjs";
+import { BuiltInSortFn } from "../../fns/sortFns.cjs";
+import { Row } from "../../types/Row.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table } from "../../types/Table.cjs";
+import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.cjs";
+
+//#region src/features/row-sorting/rowSortingFeature.types.d.ts
+type SortDirection = 'asc' | 'desc';
+interface ColumnSort {
+  desc: boolean;
+  id: string;
+}
+type SortingState = Array<ColumnSort>;
+interface TableState_RowSorting {
+  sorting: SortingState;
+}
+interface RowModelFns_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  sortFns: Record<keyof SortFns, SortFn<TFeatures, TData>>;
+}
+interface SortFns {}
+interface SortFn<TFeatures extends TableFeatures, TData extends RowData> {
+  (rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string): number;
+}
+type CustomSortFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, SortFn<TFeatures, TData>>;
+type SortFnOption<TFeatures extends TableFeatures, TData extends RowData> = 'auto' | keyof SortFns | BuiltInSortFn | SortFn<TFeatures, TData>;
+interface ColumnDef_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Enables/Disables multi-sorting for this column.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for this column.
+   */
+  enableSorting?: boolean;
+  /**
+   * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, eg. a ranking (1st, 2nd, 3rd) or golf-like scoring
+   */
+  invertSorting?: boolean;
+  /**
+   * Set to `true` for sorting toggles on this column to start in the descending direction.
+   */
+  sortDescFirst?: boolean;
+  /**
+   * The sorting function to use with this column.
+   * - A `string` referencing a built-in sorting function
+   * - A custom sorting function
+   */
+  sortFn?: SortFnOption<TFeatures, TData>;
+  /**
+   * The priority of undefined values when sorting this column.
+   * - `false`
+   *   - Undefined values will be considered tied and need to be sorted by the next column filter or original index (whichever applies)
+   * - `-1`
+   *   - Undefined values will be sorted with higher priority (ascending) (if ascending, undefined will appear on the beginning of the list)
+   * - `1`
+   *   - Undefined values will be sorted with lower priority (descending) (if ascending, undefined will appear on the end of the list)
+   */
+  sortUndefined?: false | -1 | 1 | 'first' | 'last';
+}
+interface Column_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Removes this column from the table's sorting state
+   */
+  clearSorting: () => void;
+  /**
+   * Returns a sort direction automatically inferred based on the columns values.
+   */
+  getAutoSortDir: () => SortDirection;
+  /**
+   * Returns a sorting function automatically inferred based on the columns values.
+   */
+  getAutoSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Returns whether this column can be multi-sorted.
+   */
+  getCanMultiSort: () => boolean;
+  /**
+   * Returns whether this column can be sorted.
+   */
+  getCanSort: () => boolean;
+  /**
+   * Returns the first direction that should be used when sorting this column.
+   */
+  getFirstSortDir: () => SortDirection;
+  /**
+   * Returns the current sort direction of this column.
+   */
+  getIsSorted: () => false | SortDirection;
+  /**
+   * Returns the next sorting order.
+   */
+  getNextSortingOrder: () => SortDirection | false;
+  /**
+   * Returns the index position of this column's sorting within the sorting state
+   */
+  getSortIndex: () => number;
+  /**
+   * Returns the resolved sorting function to be used for this column
+   */
+  getSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Returns a function that can be used to toggle this column's sorting state. This is useful for attaching a click handler to the column header.
+   */
+  getToggleSortingHandler: () => undefined | ((event: unknown) => void);
+  /**
+   * Toggles this columns sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).
+   */
+  toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+}
+interface TableOptions_RowSorting {
+  /**
+   * Enables/disables the ability to remove multi-sorts
+   */
+  enableMultiRemove?: boolean;
+  /**
+   * Enables/Disables multi-sorting for the table.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for the table.
+   */
+  enableSorting?: boolean;
+  /**
+   * Enables/Disables the ability to remove sorting for the table.
+   * - If `true` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...
+   * - If `false` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...
+   */
+  enableSortingRemoval?: boolean;
+  /**
+   * Pass a custom function that will be used to determine if a multi-sort event should be triggered. It is passed the event from the sort toggle handler and should return `true` if the event should trigger a multi-sort.
+   */
+  isMultiSortEvent?: (e: unknown) => boolean;
+  /**
+   * Enables manual sorting for the table. If this is `true`, you will be expected to sort your data before it is passed to the table. This is useful if you are doing server-side sorting.
+   */
+  manualSorting?: boolean;
+  /**
+   * Set a maximum number of columns that can be multi-sorted.
+   */
+  maxMultiSortColCount?: number;
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.sorting` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.
+   */
+  onSortingChange?: OnChangeFn<SortingState>;
+  /**
+   * If `true`, all sorts will default to descending as their first toggle state.
+   */
+  sortDescFirst?: boolean;
+}
+interface Table_RowSorting<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Resets the **sorting** state to `initialState.sorting`, or `true` can be passed to force a default blank state reset to `[]`.
+   */
+  resetSorting: (defaultState?: boolean) => void;
+  /**
+   * Sets or updates the `state.sorting` state.
+   */
+  setSorting: (updater: Updater<SortingState>) => void;
+}
+interface Table_RowModels_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * Returns the row model for the table before any sorting has been applied.
+   */
+  getPreSortedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the row model for the table after sorting has been applied.
+   */
+  getSortedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CreateRowModel_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+  /**
+   * This function is used to retrieve the sorted row model. If using server-side sorting, this function is not required. To use client-side sorting, pass the exported `getSortedRowModel()` from your adapter to your table or implement your own.
+   */
+  sortedRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Sorted<TFeatures extends TableFeatures, TData extends RowData> {
+  sortedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+export { CachedRowModel_Sorted, ColumnDef_RowSorting, ColumnSort, Column_RowSorting, CreateRowModel_Sorted, CustomSortFns, RowModelFns_RowSorting, SortDirection, SortFn, SortFnOption, SortFns, SortingState, TableOptions_RowSorting, TableState_RowSorting, Table_RowModels_Sorted, Table_RowSorting };
+//# sourceMappingURL=rowSortingFeature.types.d.cts.map