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

package/dist/features/column-resizing/columnResizingFeature.cjs

@@ -0,0 +1,46 @@
+const require_utils = require('../../utils.cjs');
+const require_columnResizingFeature_utils = require('./columnResizingFeature.utils.cjs');
+
+//#region src/features/column-resizing/columnResizingFeature.ts
+function constructColumnResizingFeature() {
+	return {
+		getInitialState: (initialState) => {
+			return {
+				columnResizing: require_columnResizingFeature_utils.getDefaultColumnResizingState(),
+				...initialState
+			};
+		},
+		getDefaultTableOptions: (table) => {
+			return {
+				columnResizeMode: "onEnd",
+				columnResizeDirection: "ltr",
+				onColumnResizingChange: require_utils.makeStateUpdater("columnResizing", table)
+			};
+		},
+		assignColumnPrototype: (prototype, table) => {
+			require_utils.assignPrototypeAPIs("columnResizingFeature", prototype, table, {
+				column_getCanResize: { fn: (column) => require_columnResizingFeature_utils.column_getCanResize(column) },
+				column_getIsResizing: { fn: (column) => require_columnResizingFeature_utils.column_getIsResizing(column) }
+			});
+		},
+		assignHeaderPrototype: (prototype, table) => {
+			require_utils.assignPrototypeAPIs("columnResizingFeature", prototype, table, { header_getResizeHandler: { fn: (header, _contextDocument) => require_columnResizingFeature_utils.header_getResizeHandler(header, _contextDocument) } });
+		},
+		constructTableAPIs: (table) => {
+			require_utils.assignTableAPIs("columnResizingFeature", table, {
+				table_setColumnResizing: { fn: (updater) => require_columnResizingFeature_utils.table_setColumnResizing(table, updater) },
+				table_resetHeaderSizeInfo: { fn: (defaultState) => require_columnResizingFeature_utils.table_resetHeaderSizeInfo(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The Column Resizing feature adds column resizing state and APIs to the table and column objects.
+* **Note:** This is dependent on the Column Sizing feature.
+*/
+const columnResizingFeature = constructColumnResizingFeature();
+
+//#endregion
+exports.columnResizingFeature = columnResizingFeature;
+exports.constructColumnResizingFeature = constructColumnResizingFeature;
+//# sourceMappingURL=columnResizingFeature.cjs.map

package/dist/features/column-resizing/columnResizingFeature.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnResizingFeature.cjs","names":["getDefaultColumnResizingState","makeStateUpdater","column_getCanResize","column_getIsResizing","header_getResizeHandler","table_setColumnResizing","table_resetHeaderSizeInfo"],"sources":["../../../src/features/column-resizing/columnResizingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanResize,\n  column_getIsResizing,\n  getDefaultColumnResizingState,\n  header_getResizeHandler,\n  table_resetHeaderSizeInfo,\n  table_setColumnResizing,\n} from './columnResizingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Column_ColumnResizing,\n//   Header_ColumnResizing,\n//   TableOptions_ColumnResizing,\n//   TableState_ColumnResizing,\n//   Table_ColumnResizing,\n// } from './columnResizingFeature.types'\n\nexport interface ColumnResizingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Column: Column_ColumnResizing\n  // Header: Header_ColumnResizing\n  // Table: Table_ColumnResizing\n  // TableOptions: TableOptions_ColumnResizing\n  // TableState: TableState_ColumnResizing\n}\n\nexport function constructColumnResizingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnResizingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState: (initialState) => {\n      return {\n        columnResizing: getDefaultColumnResizingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultTableOptions: (table) => {\n      return {\n        columnResizeMode: 'onEnd',\n        columnResizeDirection: 'ltr',\n        onColumnResizingChange: makeStateUpdater('columnResizing', table),\n      }\n    },\n\n    assignColumnPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnResizingFeature', prototype, table, {\n        column_getCanResize: {\n          fn: (column) => column_getCanResize(column),\n        },\n        column_getIsResizing: {\n          fn: (column) => column_getIsResizing(column),\n        },\n      })\n    },\n\n    assignHeaderPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnResizingFeature', prototype, table, {\n        header_getResizeHandler: {\n          fn: (header, _contextDocument) =>\n            header_getResizeHandler(header, _contextDocument),\n        },\n      })\n    },\n\n    constructTableAPIs: (table) => {\n      assignTableAPIs('columnResizingFeature', table, {\n        table_setColumnResizing: {\n          fn: (updater) => table_setColumnResizing(table, updater),\n        },\n        table_resetHeaderSizeInfo: {\n          fn: (defaultState) => table_resetHeaderSizeInfo(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Column Resizing feature adds column resizing state and APIs to the table and column objects.\n * **Note:** This is dependent on the Column Sizing feature.\n */\nexport const columnResizingFeature = constructColumnResizingFeature()\n"],"mappings":";;;;AAkCA,SAAgB,iCAGuD;AACrE,QAAO;EACL,kBAAkB,iBAAiB;AACjC,UAAO;IACL,gBAAgBA,mEAA+B;IAC/C,GAAG;IACJ;;EAGH,yBAAyB,UAAU;AACjC,UAAO;IACL,kBAAkB;IAClB,uBAAuB;IACvB,wBAAwBC,+BAAiB,kBAAkB,MAAM;IAClE;;EAGH,wBAAwB,WAAW,UAAU;AAC3C,qCAAoB,yBAAyB,WAAW,OAAO;IAC7D,qBAAqB,EACnB,KAAK,WAAWC,wDAAoB,OAAO,EAC5C;IACD,sBAAsB,EACpB,KAAK,WAAWC,yDAAqB,OAAO,EAC7C;IACF,CAAC;;EAGJ,wBAAwB,WAAW,UAAU;AAC3C,qCAAoB,yBAAyB,WAAW,OAAO,EAC7D,yBAAyB,EACvB,KAAK,QAAQ,qBACXC,4DAAwB,QAAQ,iBAAiB,EACpD,EACF,CAAC;;EAGJ,qBAAqB,UAAU;AAC7B,iCAAgB,yBAAyB,OAAO;IAC9C,yBAAyB,EACvB,KAAK,YAAYC,4DAAwB,OAAO,QAAQ,EACzD;IACD,2BAA2B,EACzB,KAAK,iBAAiBC,8DAA0B,OAAO,aAAa,EACrE;IACF,CAAC;;EAEL;;;;;;AAOH,MAAa,wBAAwB,gCAAgC"}

package/dist/features/column-resizing/columnResizingFeature.d.cts

@@ -0,0 +1,14 @@
+import { RowData } from "../../types/type-utils.cjs";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.cjs";
+
+//#region src/features/column-resizing/columnResizingFeature.d.ts
+interface ColumnResizingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+declare function constructColumnResizingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnResizingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Column Resizing feature adds column resizing state and APIs to the table and column objects.
+ * **Note:** This is dependent on the Column Sizing feature.
+ */
+declare const columnResizingFeature: TableFeature<ColumnResizingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { ColumnResizingFeatureConstructors, columnResizingFeature, constructColumnResizingFeature };
+//# sourceMappingURL=columnResizingFeature.d.cts.map

package/dist/features/column-resizing/columnResizingFeature.d.ts

@@ -0,0 +1,14 @@
+import { RowData } from "../../types/type-utils.js";
+import { TableFeature, TableFeatures } from "../../types/TableFeatures.js";
+
+//#region src/features/column-resizing/columnResizingFeature.d.ts
+interface ColumnResizingFeatureConstructors<TFeatures extends TableFeatures, TData extends RowData> {}
+declare function constructColumnResizingFeature<TFeatures extends TableFeatures, TData extends RowData>(): TableFeature<ColumnResizingFeatureConstructors<TFeatures, TData>>;
+/**
+ * The Column Resizing feature adds column resizing state and APIs to the table and column objects.
+ * **Note:** This is dependent on the Column Sizing feature.
+ */
+declare const columnResizingFeature: TableFeature<ColumnResizingFeatureConstructors<TableFeatures, RowData>>;
+//#endregion
+export { ColumnResizingFeatureConstructors, columnResizingFeature, constructColumnResizingFeature };
+//# sourceMappingURL=columnResizingFeature.d.ts.map

package/dist/features/column-resizing/columnResizingFeature.js

@@ -0,0 +1,45 @@
+import { assignPrototypeAPIs, assignTableAPIs, makeStateUpdater } from "../../utils.js";
+import { column_getCanResize, column_getIsResizing, getDefaultColumnResizingState, header_getResizeHandler, table_resetHeaderSizeInfo, table_setColumnResizing } from "./columnResizingFeature.utils.js";
+
+//#region src/features/column-resizing/columnResizingFeature.ts
+function constructColumnResizingFeature() {
+	return {
+		getInitialState: (initialState) => {
+			return {
+				columnResizing: getDefaultColumnResizingState(),
+				...initialState
+			};
+		},
+		getDefaultTableOptions: (table) => {
+			return {
+				columnResizeMode: "onEnd",
+				columnResizeDirection: "ltr",
+				onColumnResizingChange: makeStateUpdater("columnResizing", table)
+			};
+		},
+		assignColumnPrototype: (prototype, table) => {
+			assignPrototypeAPIs("columnResizingFeature", prototype, table, {
+				column_getCanResize: { fn: (column) => column_getCanResize(column) },
+				column_getIsResizing: { fn: (column) => column_getIsResizing(column) }
+			});
+		},
+		assignHeaderPrototype: (prototype, table) => {
+			assignPrototypeAPIs("columnResizingFeature", prototype, table, { header_getResizeHandler: { fn: (header, _contextDocument) => header_getResizeHandler(header, _contextDocument) } });
+		},
+		constructTableAPIs: (table) => {
+			assignTableAPIs("columnResizingFeature", table, {
+				table_setColumnResizing: { fn: (updater) => table_setColumnResizing(table, updater) },
+				table_resetHeaderSizeInfo: { fn: (defaultState) => table_resetHeaderSizeInfo(table, defaultState) }
+			});
+		}
+	};
+}
+/**
+* The Column Resizing feature adds column resizing state and APIs to the table and column objects.
+* **Note:** This is dependent on the Column Sizing feature.
+*/
+const columnResizingFeature = constructColumnResizingFeature();
+
+//#endregion
+export { columnResizingFeature, constructColumnResizingFeature };
+//# sourceMappingURL=columnResizingFeature.js.map

package/dist/features/column-resizing/columnResizingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnResizingFeature.js","names":[],"sources":["../../../src/features/column-resizing/columnResizingFeature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n} from '../../utils'\nimport {\n  column_getCanResize,\n  column_getIsResizing,\n  getDefaultColumnResizingState,\n  header_getResizeHandler,\n  table_resetHeaderSizeInfo,\n  table_setColumnResizing,\n} from './columnResizingFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Column_ColumnResizing,\n//   Header_ColumnResizing,\n//   TableOptions_ColumnResizing,\n//   TableState_ColumnResizing,\n//   Table_ColumnResizing,\n// } from './columnResizingFeature.types'\n\nexport interface ColumnResizingFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Column: Column_ColumnResizing\n  // Header: Header_ColumnResizing\n  // Table: Table_ColumnResizing\n  // TableOptions: TableOptions_ColumnResizing\n  // TableState: TableState_ColumnResizing\n}\n\nexport function constructColumnResizingFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<ColumnResizingFeatureConstructors<TFeatures, TData>> {\n  return {\n    getInitialState: (initialState) => {\n      return {\n        columnResizing: getDefaultColumnResizingState(),\n        ...initialState,\n      }\n    },\n\n    getDefaultTableOptions: (table) => {\n      return {\n        columnResizeMode: 'onEnd',\n        columnResizeDirection: 'ltr',\n        onColumnResizingChange: makeStateUpdater('columnResizing', table),\n      }\n    },\n\n    assignColumnPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnResizingFeature', prototype, table, {\n        column_getCanResize: {\n          fn: (column) => column_getCanResize(column),\n        },\n        column_getIsResizing: {\n          fn: (column) => column_getIsResizing(column),\n        },\n      })\n    },\n\n    assignHeaderPrototype: (prototype, table) => {\n      assignPrototypeAPIs('columnResizingFeature', prototype, table, {\n        header_getResizeHandler: {\n          fn: (header, _contextDocument) =>\n            header_getResizeHandler(header, _contextDocument),\n        },\n      })\n    },\n\n    constructTableAPIs: (table) => {\n      assignTableAPIs('columnResizingFeature', table, {\n        table_setColumnResizing: {\n          fn: (updater) => table_setColumnResizing(table, updater),\n        },\n        table_resetHeaderSizeInfo: {\n          fn: (defaultState) => table_resetHeaderSizeInfo(table, defaultState),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Column Resizing feature adds column resizing state and APIs to the table and column objects.\n * **Note:** This is dependent on the Column Sizing feature.\n */\nexport const columnResizingFeature = constructColumnResizingFeature()\n"],"mappings":";;;;AAkCA,SAAgB,iCAGuD;AACrE,QAAO;EACL,kBAAkB,iBAAiB;AACjC,UAAO;IACL,gBAAgB,+BAA+B;IAC/C,GAAG;IACJ;;EAGH,yBAAyB,UAAU;AACjC,UAAO;IACL,kBAAkB;IAClB,uBAAuB;IACvB,wBAAwB,iBAAiB,kBAAkB,MAAM;IAClE;;EAGH,wBAAwB,WAAW,UAAU;AAC3C,uBAAoB,yBAAyB,WAAW,OAAO;IAC7D,qBAAqB,EACnB,KAAK,WAAW,oBAAoB,OAAO,EAC5C;IACD,sBAAsB,EACpB,KAAK,WAAW,qBAAqB,OAAO,EAC7C;IACF,CAAC;;EAGJ,wBAAwB,WAAW,UAAU;AAC3C,uBAAoB,yBAAyB,WAAW,OAAO,EAC7D,yBAAyB,EACvB,KAAK,QAAQ,qBACX,wBAAwB,QAAQ,iBAAiB,EACpD,EACF,CAAC;;EAGJ,qBAAqB,UAAU;AAC7B,mBAAgB,yBAAyB,OAAO;IAC9C,yBAAyB,EACvB,KAAK,YAAY,wBAAwB,OAAO,QAAQ,EACzD;IACD,2BAA2B,EACzB,KAAK,iBAAiB,0BAA0B,OAAO,aAAa,EACrE;IACF,CAAC;;EAEL;;;;;;AAOH,MAAa,wBAAwB,gCAAgC"}

package/dist/features/column-resizing/columnResizingFeature.types.d.cts

@@ -0,0 +1,73 @@
+import { OnChangeFn, Updater } from "../../types/type-utils.cjs";
+
+//#region src/features/column-resizing/columnResizingFeature.types.d.ts
+interface TableState_ColumnResizing {
+  columnResizing: columnResizingState;
+}
+interface columnResizingState {
+  columnSizingStart: Array<[string, number]>;
+  deltaOffset: null | number;
+  deltaPercentage: null | number;
+  isResizingColumn: false | string;
+  startOffset: null | number;
+  startSize: null | number;
+}
+type ColumnResizeMode = 'onChange' | 'onEnd';
+type ColumnResizeDirection = 'ltr' | 'rtl';
+interface TableOptions_ColumnResizing {
+  /**
+   * Determines when the columnSizing state is updated. `onChange` updates the state when the user is dragging the resize handle. `onEnd` updates the state when the user releases the resize handle.
+   */
+  columnResizeMode?: ColumnResizeMode;
+  /**
+   * Enables or disables column resizing for the column.
+   */
+  enableColumnResizing?: boolean;
+  /**
+   * Enables or disables right-to-left support for resizing the column. defaults to 'ltr'.
+   */
+  columnResizeDirection?: ColumnResizeDirection;
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.columnResizing` changes. This overrides the default internal state management, so you will also need to supply `state.columnResizing` from your own managed state.
+   */
+  onColumnResizingChange?: OnChangeFn<columnResizingState>;
+}
+type ColumnResizingDefaultOptions = Pick<TableOptions_ColumnResizing, 'columnResizeMode' | 'onColumnResizingChange' | 'columnResizeDirection'>;
+interface Table_ColumnResizing {
+  /**
+   * Resets column sizing info to its initial state. If `defaultState` is `true`, the default state for the table will be used instead of the initialValue provided to the table.
+   */
+  resetHeaderSizeInfo: (defaultState?: boolean) => void;
+  /**
+   * Sets the column sizing info state using an updater function or a value. This will trigger the underlying `oncolumnResizingChange` function if one is passed to the table options, otherwise the state will be managed automatically by the table.
+   */
+  setcolumnResizing: (updater: Updater<columnResizingState>) => void;
+}
+interface ColumnDef_ColumnResizing {
+  /**
+   * Enables or disables column resizing for the column.
+   */
+  enableResizing?: boolean;
+}
+interface Column_ColumnResizing {
+  /**
+   * Returns `true` if the column can be resized.
+   */
+  getCanResize: () => boolean;
+  /**
+   * Returns `true` if the column is currently being resized.
+   */
+  getIsResizing: () => boolean;
+}
+interface Header_ColumnResizing {
+  /**
+   * Returns an event handler function that can be used to resize the header. It can be used as an:
+   * - `onMouseDown` handler
+   * - `onTouchStart` handler
+   * The dragging and release events are automatically handled for you.
+   */
+  getResizeHandler: (context?: Document) => (event: unknown) => void;
+}
+//#endregion
+export { ColumnDef_ColumnResizing, ColumnResizeDirection, ColumnResizeMode, ColumnResizingDefaultOptions, Column_ColumnResizing, Header_ColumnResizing, TableOptions_ColumnResizing, TableState_ColumnResizing, Table_ColumnResizing, columnResizingState };
+//# sourceMappingURL=columnResizingFeature.types.d.cts.map

package/dist/features/column-resizing/columnResizingFeature.types.d.ts

@@ -0,0 +1,73 @@
+import { OnChangeFn, Updater } from "../../types/type-utils.js";
+
+//#region src/features/column-resizing/columnResizingFeature.types.d.ts
+interface TableState_ColumnResizing {
+  columnResizing: columnResizingState;
+}
+interface columnResizingState {
+  columnSizingStart: Array<[string, number]>;
+  deltaOffset: null | number;
+  deltaPercentage: null | number;
+  isResizingColumn: false | string;
+  startOffset: null | number;
+  startSize: null | number;
+}
+type ColumnResizeMode = 'onChange' | 'onEnd';
+type ColumnResizeDirection = 'ltr' | 'rtl';
+interface TableOptions_ColumnResizing {
+  /**
+   * Determines when the columnSizing state is updated. `onChange` updates the state when the user is dragging the resize handle. `onEnd` updates the state when the user releases the resize handle.
+   */
+  columnResizeMode?: ColumnResizeMode;
+  /**
+   * Enables or disables column resizing for the column.
+   */
+  enableColumnResizing?: boolean;
+  /**
+   * Enables or disables right-to-left support for resizing the column. defaults to 'ltr'.
+   */
+  columnResizeDirection?: ColumnResizeDirection;
+  /**
+   * If provided, this function will be called with an `updaterFn` when `state.columnResizing` changes. This overrides the default internal state management, so you will also need to supply `state.columnResizing` from your own managed state.
+   */
+  onColumnResizingChange?: OnChangeFn<columnResizingState>;
+}
+type ColumnResizingDefaultOptions = Pick<TableOptions_ColumnResizing, 'columnResizeMode' | 'onColumnResizingChange' | 'columnResizeDirection'>;
+interface Table_ColumnResizing {
+  /**
+   * Resets column sizing info to its initial state. If `defaultState` is `true`, the default state for the table will be used instead of the initialValue provided to the table.
+   */
+  resetHeaderSizeInfo: (defaultState?: boolean) => void;
+  /**
+   * Sets the column sizing info state using an updater function or a value. This will trigger the underlying `oncolumnResizingChange` function if one is passed to the table options, otherwise the state will be managed automatically by the table.
+   */
+  setcolumnResizing: (updater: Updater<columnResizingState>) => void;
+}
+interface ColumnDef_ColumnResizing {
+  /**
+   * Enables or disables column resizing for the column.
+   */
+  enableResizing?: boolean;
+}
+interface Column_ColumnResizing {
+  /**
+   * Returns `true` if the column can be resized.
+   */
+  getCanResize: () => boolean;
+  /**
+   * Returns `true` if the column is currently being resized.
+   */
+  getIsResizing: () => boolean;
+}
+interface Header_ColumnResizing {
+  /**
+   * Returns an event handler function that can be used to resize the header. It can be used as an:
+   * - `onMouseDown` handler
+   * - `onTouchStart` handler
+   * The dragging and release events are automatically handled for you.
+   */
+  getResizeHandler: (context?: Document) => (event: unknown) => void;
+}
+//#endregion
+export { ColumnDef_ColumnResizing, ColumnResizeDirection, ColumnResizeMode, ColumnResizingDefaultOptions, Column_ColumnResizing, Header_ColumnResizing, TableOptions_ColumnResizing, TableState_ColumnResizing, Table_ColumnResizing, columnResizingState };
+//# sourceMappingURL=columnResizingFeature.types.d.ts.map

package/dist/features/column-resizing/columnResizingFeature.utils.cjs

@@ -0,0 +1,157 @@
+const require_utils = require('../../utils.cjs');
+const require_coreColumnsFeature_utils = require('../../core/columns/coreColumnsFeature.utils.cjs');
+const require_columnSizingFeature_utils = require('../column-sizing/columnSizingFeature.utils.cjs');
+
+//#region src/features/column-resizing/columnResizingFeature.utils.ts
+function getDefaultColumnResizingState() {
+	return {
+		startOffset: null,
+		startSize: null,
+		deltaOffset: null,
+		deltaPercentage: null,
+		isResizingColumn: false,
+		columnSizingStart: []
+	};
+}
+function column_getCanResize(column) {
+	return (column.columnDef.enableResizing ?? true) && (column.table.options.enableColumnResizing ?? true);
+}
+function column_getIsResizing(column) {
+	var _column$table$atoms$c;
+	return ((_column$table$atoms$c = column.table.atoms.columnResizing) === null || _column$table$atoms$c === void 0 || (_column$table$atoms$c = _column$table$atoms$c.get()) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.isResizingColumn) === column.id;
+}
+function header_getResizeHandler(header, _contextDocument) {
+	const column = require_coreColumnsFeature_utils.table_getColumn(header.column.table, header.column.id);
+	const canResize = column_getCanResize(column);
+	return (event) => {
+		var _persist;
+		if (!canResize) return;
+		(_persist = event.persist) === null || _persist === void 0 || _persist.call(event);
+		if (isTouchStartEvent(event)) {
+			if (event.touches.length > 1) return;
+		}
+		const startSize = require_columnSizingFeature_utils.header_getSize(header);
+		const columnSizingStart = header.getLeafHeaders().map((leafHeader) => [leafHeader.column.id, require_columnSizingFeature_utils.column_getSize(leafHeader.column)]);
+		const clientX = isTouchStartEvent(event) ? Math.round(event.touches[0].clientX) : event.clientX;
+		const newColumnSizing = {};
+		const updateOffset = (eventType, clientXPos) => {
+			if (typeof clientXPos !== "number") return;
+			table_setColumnResizing(column.table, (old) => {
+				const deltaDirection = column.table.options.columnResizeDirection === "rtl" ? -1 : 1;
+				const deltaOffset = (clientXPos - (old.startOffset ?? 0)) * deltaDirection;
+				const startSize = old.startSize ?? 0;
+				const deltaPercentage = Math.max(startSize > 0 ? deltaOffset / startSize : 0, -.999999);
+				old.columnSizingStart.forEach(([columnId, headerSize]) => {
+					newColumnSizing[columnId] = Math.round(Math.max(headerSize > 0 ? headerSize + headerSize * deltaPercentage : deltaOffset / old.columnSizingStart.length, 0) * 100) / 100;
+				});
+				return {
+					...old,
+					deltaOffset,
+					deltaPercentage
+				};
+			});
+			if (column.table.options.columnResizeMode === "onChange" || eventType === "end") require_columnSizingFeature_utils.table_setColumnSizing(column.table, (old) => ({
+				...old,
+				...newColumnSizing
+			}));
+		};
+		const onMove = (clientXPos) => updateOffset("move", clientXPos);
+		const onEnd = (clientXPos) => {
+			updateOffset("end", clientXPos);
+			table_setColumnResizing(column.table, (old) => ({
+				...old,
+				isResizingColumn: false,
+				startOffset: null,
+				startSize: null,
+				deltaOffset: null,
+				deltaPercentage: null,
+				columnSizingStart: []
+			}));
+		};
+		const contextDocument = _contextDocument || typeof document !== "undefined" ? document : null;
+		const mouseEvents = {
+			moveHandler: (e) => onMove(e.clientX),
+			upHandler: (e) => {
+				contextDocument === null || contextDocument === void 0 || contextDocument.removeEventListener("mousemove", mouseEvents.moveHandler);
+				contextDocument === null || contextDocument === void 0 || contextDocument.removeEventListener("mouseup", mouseEvents.upHandler);
+				onEnd(e.clientX);
+			}
+		};
+		const touchEvents = {
+			moveHandler: (touchEvent) => {
+				if (touchEvent.cancelable) {
+					touchEvent.preventDefault();
+					touchEvent.stopPropagation();
+				}
+				onMove(touchEvent.touches[0].clientX);
+				return false;
+			},
+			upHandler: (e) => {
+				var _e$touches$;
+				contextDocument === null || contextDocument === void 0 || contextDocument.removeEventListener("touchmove", touchEvents.moveHandler);
+				contextDocument === null || contextDocument === void 0 || contextDocument.removeEventListener("touchend", touchEvents.upHandler);
+				if (e.cancelable) {
+					e.preventDefault();
+					e.stopPropagation();
+				}
+				onEnd((_e$touches$ = e.touches[0]) === null || _e$touches$ === void 0 ? void 0 : _e$touches$.clientX);
+			}
+		};
+		const passiveIfSupported = passiveEventSupported() ? { passive: false } : false;
+		if (isTouchStartEvent(event)) {
+			contextDocument === null || contextDocument === void 0 || contextDocument.addEventListener("touchmove", touchEvents.moveHandler, passiveIfSupported);
+			contextDocument === null || contextDocument === void 0 || contextDocument.addEventListener("touchend", touchEvents.upHandler, passiveIfSupported);
+		} else {
+			contextDocument === null || contextDocument === void 0 || contextDocument.addEventListener("mousemove", mouseEvents.moveHandler, passiveIfSupported);
+			contextDocument === null || contextDocument === void 0 || contextDocument.addEventListener("mouseup", mouseEvents.upHandler, passiveIfSupported);
+		}
+		table_setColumnResizing(column.table, (old) => ({
+			...old,
+			startOffset: clientX,
+			startSize,
+			deltaOffset: 0,
+			deltaPercentage: 0,
+			columnSizingStart,
+			isResizingColumn: column.id
+		}));
+	};
+}
+function table_setColumnResizing(table, updater) {
+	var _table$options$onColu, _table$options;
+	(_table$options$onColu = (_table$options = table.options).onColumnResizingChange) === null || _table$options$onColu === void 0 || _table$options$onColu.call(_table$options, updater);
+}
+function table_resetHeaderSizeInfo(table, defaultState) {
+	table_setColumnResizing(table, defaultState ? getDefaultColumnResizingState() : require_utils.cloneState(table.initialState.columnResizing ?? getDefaultColumnResizingState()));
+}
+function passiveEventSupported() {
+	let passiveSupported = null;
+	if (typeof passiveSupported === "boolean") return passiveSupported;
+	let supported = false;
+	try {
+		const options = { get passive() {
+			supported = true;
+			return false;
+		} };
+		const noop = () => {};
+		window.addEventListener("test", noop, options);
+		window.removeEventListener("test", noop);
+	} catch (err) {
+		supported = false;
+	}
+	passiveSupported = supported;
+	return passiveSupported;
+}
+function isTouchStartEvent(e) {
+	return e.type === "touchstart";
+}
+
+//#endregion
+exports.column_getCanResize = column_getCanResize;
+exports.column_getIsResizing = column_getIsResizing;
+exports.getDefaultColumnResizingState = getDefaultColumnResizingState;
+exports.header_getResizeHandler = header_getResizeHandler;
+exports.isTouchStartEvent = isTouchStartEvent;
+exports.passiveEventSupported = passiveEventSupported;
+exports.table_resetHeaderSizeInfo = table_resetHeaderSizeInfo;
+exports.table_setColumnResizing = table_setColumnResizing;
+//# sourceMappingURL=columnResizingFeature.utils.cjs.map

package/dist/features/column-resizing/columnResizingFeature.utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnResizingFeature.utils.cjs","names":["table_getColumn","header_getSize","column_getSize","cloneState"],"sources":["../../../src/features/column-resizing/columnResizingFeature.utils.ts"],"sourcesContent":["import {\n  column_getSize,\n  header_getSize,\n  table_setColumnSizing,\n} from '../column-sizing/columnSizingFeature.utils'\nimport { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'\nimport { cloneState } from '../../utils'\nimport type { CellData, RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { Column_Internal } from '../../types/Column'\nimport type { ColumnSizingState } from '../column-sizing/columnSizingFeature.types'\nimport type { columnResizingState } from './columnResizingFeature.types'\n\nexport function getDefaultColumnResizingState(): columnResizingState {\n  return {\n    startOffset: null,\n    startSize: null,\n    deltaOffset: null,\n    deltaPercentage: null,\n    isResizingColumn: false,\n    columnSizingStart: [],\n  }\n}\n\nexport function column_getCanResize<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    (column.columnDef.enableResizing ?? true) &&\n    (column.table.options.enableColumnResizing ?? true)\n  )\n}\n\nexport function column_getIsResizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(column: Column_Internal<TFeatures, TData, TValue>) {\n  return (\n    column.table.atoms.columnResizing?.get()?.isResizingColumn === column.id\n  )\n}\n\nexport function header_getResizeHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(header: Header<TFeatures, TData, TValue>, _contextDocument?: Document) {\n  const column = table_getColumn(header.column.table, header.column.id)!\n  const canResize = column_getCanResize(column)\n\n  return (event: unknown) => {\n    if (!canResize) {\n      return\n    }\n\n    ;(event as any).persist?.()\n\n    if (isTouchStartEvent(event)) {\n      // lets not respond to multiple touches (e.g. 2 or 3 fingers)\n      if (event.touches.length > 1) {\n        return\n      }\n    }\n\n    const startSize = header_getSize(header)\n\n    const columnSizingStart: Array<[string, number]> = header\n      .getLeafHeaders()\n      .map((leafHeader) => [\n        leafHeader.column.id,\n        column_getSize(leafHeader.column),\n      ])\n\n    const clientX = isTouchStartEvent(event)\n      ? Math.round(event.touches[0]!.clientX)\n      : (event as MouseEvent).clientX\n\n    const newColumnSizing: ColumnSizingState = {}\n\n    const updateOffset = (eventType: 'move' | 'end', clientXPos?: number) => {\n      if (typeof clientXPos !== 'number') {\n        return\n      }\n\n      table_setColumnResizing(column.table, (old) => {\n        const deltaDirection =\n          column.table.options.columnResizeDirection === 'rtl' ? -1 : 1\n        const deltaOffset =\n          (clientXPos - (old.startOffset ?? 0)) * deltaDirection\n        const startSize = old.startSize ?? 0\n        const deltaPercentage = Math.max(\n          startSize > 0 ? deltaOffset / startSize : 0,\n          -0.999999,\n        )\n\n        old.columnSizingStart.forEach(([columnId, headerSize]) => {\n          newColumnSizing[columnId] =\n            Math.round(\n              Math.max(\n                headerSize > 0\n                  ? headerSize + headerSize * deltaPercentage\n                  : deltaOffset / old.columnSizingStart.length,\n                0,\n              ) * 100,\n            ) / 100\n        })\n\n        return {\n          ...old,\n          deltaOffset,\n          deltaPercentage,\n        }\n      })\n\n      if (\n        column.table.options.columnResizeMode === 'onChange' ||\n        eventType === 'end'\n      ) {\n        table_setColumnSizing(column.table, (old) => ({\n          ...old,\n          ...newColumnSizing,\n        }))\n      }\n    }\n\n    const onMove = (clientXPos?: number) => updateOffset('move', clientXPos)\n\n    const onEnd = (clientXPos?: number) => {\n      updateOffset('end', clientXPos)\n\n      table_setColumnResizing(column.table, (old) => ({\n        ...old,\n        isResizingColumn: false,\n        startOffset: null,\n        startSize: null,\n        deltaOffset: null,\n        deltaPercentage: null,\n        columnSizingStart: [],\n      }))\n    }\n\n    const contextDocument =\n      _contextDocument || typeof document !== 'undefined' ? document : null\n\n    const mouseEvents = {\n      moveHandler: (e: MouseEvent) => onMove(e.clientX),\n      upHandler: (e: MouseEvent) => {\n        contextDocument?.removeEventListener(\n          'mousemove',\n          mouseEvents.moveHandler,\n        )\n        contextDocument?.removeEventListener('mouseup', mouseEvents.upHandler)\n        onEnd(e.clientX)\n      },\n    }\n\n    const touchEvents = {\n      moveHandler: (touchEvent: TouchEvent) => {\n        if (touchEvent.cancelable) {\n          touchEvent.preventDefault()\n          touchEvent.stopPropagation()\n        }\n        onMove(touchEvent.touches[0]!.clientX)\n        return false\n      },\n      upHandler: (e: TouchEvent) => {\n        contextDocument?.removeEventListener(\n          'touchmove',\n          touchEvents.moveHandler,\n        )\n        contextDocument?.removeEventListener('touchend', touchEvents.upHandler)\n        if (e.cancelable) {\n          e.preventDefault()\n          e.stopPropagation()\n        }\n        onEnd(e.touches[0]?.clientX)\n      },\n    }\n\n    const passiveIfSupported = passiveEventSupported()\n      ? { passive: false }\n      : false\n\n    if (isTouchStartEvent(event)) {\n      contextDocument?.addEventListener(\n        'touchmove',\n        touchEvents.moveHandler,\n        passiveIfSupported,\n      )\n      contextDocument?.addEventListener(\n        'touchend',\n        touchEvents.upHandler,\n        passiveIfSupported,\n      )\n    } else {\n      contextDocument?.addEventListener(\n        'mousemove',\n        mouseEvents.moveHandler,\n        passiveIfSupported,\n      )\n      contextDocument?.addEventListener(\n        'mouseup',\n        mouseEvents.upHandler,\n        passiveIfSupported,\n      )\n    }\n\n    table_setColumnResizing(column.table, (old) => ({\n      ...old,\n      startOffset: clientX,\n      startSize,\n      deltaOffset: 0,\n      deltaPercentage: 0,\n      columnSizingStart,\n      isResizingColumn: column.id,\n    }))\n  }\n}\n\nexport function table_setColumnResizing<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  updater: Updater<columnResizingState>,\n) {\n  table.options.onColumnResizingChange?.(updater)\n}\n\nexport function table_resetHeaderSizeInfo<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setColumnResizing(\n    table,\n    defaultState\n      ? getDefaultColumnResizingState()\n      : cloneState(\n          table.initialState.columnResizing ?? getDefaultColumnResizingState(),\n        ),\n  )\n}\n\nexport function passiveEventSupported() {\n  let passiveSupported: boolean | null = null\n\n  if (typeof passiveSupported === 'boolean') return passiveSupported\n\n  let supported = false\n  try {\n    const options = {\n      get passive() {\n        supported = true\n        return false\n      },\n    }\n\n    const noop = () => {}\n\n    window.addEventListener('test', noop, options)\n    window.removeEventListener('test', noop)\n  } catch (err) {\n    supported = false\n  }\n  passiveSupported = supported\n  return passiveSupported\n}\n\nexport function isTouchStartEvent(e: unknown): e is TouchEvent {\n  return (e as TouchEvent).type === 'touchstart'\n}\n"],"mappings":"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"}

package/dist/features/column-resizing/columnResizingFeature.utils.d.cts

@@ -0,0 +1,19 @@
+import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
+import { columnResizingState } from "./columnResizingFeature.types.cjs";
+import { Header } from "../../types/Header.cjs";
+import { Column_Internal } from "../../types/Column.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table_Internal } from "../../types/Table.cjs";
+
+//#region src/features/column-resizing/columnResizingFeature.utils.d.ts
+declare function getDefaultColumnResizingState(): columnResizingState;
+declare function column_getCanResize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function column_getIsResizing<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function header_getResizeHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(header: Header<TFeatures, TData, TValue>, _contextDocument?: Document): (event: unknown) => void;
+declare function table_setColumnResizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<columnResizingState>): void;
+declare function table_resetHeaderSizeInfo<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+declare function passiveEventSupported(): boolean;
+declare function isTouchStartEvent(e: unknown): e is TouchEvent;
+//#endregion
+export { column_getCanResize, column_getIsResizing, getDefaultColumnResizingState, header_getResizeHandler, isTouchStartEvent, passiveEventSupported, table_resetHeaderSizeInfo, table_setColumnResizing };
+//# sourceMappingURL=columnResizingFeature.utils.d.cts.map

package/dist/features/column-resizing/columnResizingFeature.utils.d.ts

@@ -0,0 +1,19 @@
+import { CellData, RowData, Updater } from "../../types/type-utils.js";
+import { columnResizingState } from "./columnResizingFeature.types.js";
+import { Header } from "../../types/Header.js";
+import { Column_Internal } from "../../types/Column.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+import { Table_Internal } from "../../types/Table.js";
+
+//#region src/features/column-resizing/columnResizingFeature.utils.d.ts
+declare function getDefaultColumnResizingState(): columnResizingState;
+declare function column_getCanResize<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function column_getIsResizing<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+declare function header_getResizeHandler<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(header: Header<TFeatures, TData, TValue>, _contextDocument?: Document): (event: unknown) => void;
+declare function table_setColumnResizing<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<columnResizingState>): void;
+declare function table_resetHeaderSizeInfo<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+declare function passiveEventSupported(): boolean;
+declare function isTouchStartEvent(e: unknown): e is TouchEvent;
+//#endregion
+export { column_getCanResize, column_getIsResizing, getDefaultColumnResizingState, header_getResizeHandler, isTouchStartEvent, passiveEventSupported, table_resetHeaderSizeInfo, table_setColumnResizing };
+//# sourceMappingURL=columnResizingFeature.utils.d.ts.map