@lumeweb/portal-framework-ui 0.0.1 → 0.1.1

package/dist/esm/components/data-table/ToolbarRenderer.js

@@ -0,0 +1,137 @@
+import { ToolbarItemType } from "./DataTable.types.js";
+import { getAction } from "./ToolbarRegistry.js";
+import { FilterResolver } from "./toolbarItems/FilterResolver.js";
+import { ComponentSize as ComponentSize$1 } from "../sizing/index.js";
+import { FilterGroup } from "./toolbarItems/FilterGroup.js";
+import { useMobileDetection as useMobileDetection$1 } from "./useMobileDetection.js";
+import "../index.js";
+import { Button, cn } from "@lumeweb/portal-framework-ui-core";
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/data-table/ToolbarRenderer.tsx
+const toolbarItemRenderers = /* @__PURE__ */ new Map();
+const coreSupported = new Set([
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl",
+	"3xl",
+	"4xl",
+	"5xl",
+	"6xl",
+	"7xl",
+	"auto",
+	"full"
+]);
+function ActionItemRenderer(item, commonProps, isMobile) {
+	const actionItem = getAction(item.id);
+	if (!actionItem) return null;
+	const buttonSize = isMobile ? "mobile" : actionItem.size;
+	return /* @__PURE__ */ jsxs(Button, {
+		className: actionItem.className,
+		disabled: actionItem.disabled,
+		onClick: () => actionItem.onClick(commonProps),
+		size: buttonSize,
+		title: actionItem.tooltip,
+		variant: actionItem.variant,
+		children: [actionItem.icon && /* @__PURE__ */ jsx("span", {
+			className: "mr-2",
+			children: actionItem.icon
+		}), actionItem.label]
+	});
+}
+function FilterItemRenderer(item, commonProps) {
+	const filterItem = item;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col",
+		children: [/* @__PURE__ */ jsx("label", {
+			className: "text-sm font-medium",
+			children: filterItem.label
+		}), /* @__PURE__ */ jsx(FilterResolver, {
+			filterItem,
+			commonProps
+		})]
+	});
+}
+function FilterGroupItemRenderer(item, commonProps) {
+	return /* @__PURE__ */ jsx(FilterGroup, {
+		item,
+		commonProps
+	});
+}
+function SeparatorItemRenderer(item, commonProps) {
+	return /* @__PURE__ */ jsx("div", { className: "h-6 w-px bg-gray-300" });
+}
+function registerDefaultRenderers() {
+	toolbarItemRenderers.set("action", ActionItemRenderer);
+	toolbarItemRenderers.set("filter", FilterItemRenderer);
+	toolbarItemRenderers.set("filter-group", FilterGroupItemRenderer);
+	toolbarItemRenderers.set("separator", SeparatorItemRenderer);
+}
+registerDefaultRenderers();
+const ToolbarRendererRegistry = {
+	/**
+	* Register a custom renderer for a toolbar item type
+	*/
+	register(type, renderer) {
+		toolbarItemRenderers.set(type, renderer);
+	},
+	/**
+	* Get a registered renderer for a toolbar item type
+	*/
+	get(type) {
+		return toolbarItemRenderers.get(type);
+	},
+	/**
+	* Check if a renderer is registered for a type
+	*/
+	has(type) {
+		return toolbarItemRenderers.has(type);
+	},
+	/**
+	* Remove a registered renderer
+	*/
+	remove(type) {
+		return toolbarItemRenderers.delete(type);
+	},
+	/**
+	* Clear all registered renderers
+	*/
+	clear() {
+		toolbarItemRenderers.clear();
+		registerDefaultRenderers();
+	},
+	list() {
+		return Array.from(toolbarItemRenderers.keys());
+	}
+};
+function ToolbarRenderer({ item, commonProps, className }) {
+	const mobileBreakpoint = commonProps.context?.toolbarConfig?.mobileBreakpoint;
+	const candidate = mobileBreakpoint && Object.values(ComponentSize$1).includes(mobileBreakpoint) ? mobileBreakpoint : "sm";
+	const { isMobile } = useMobileDetection$1({ mobileBreakpoint: (typeof candidate === "string" && !coreSupported.has(candidate) ? "sm" : candidate) || "sm" });
+	const containerClassName = cn("flex items-center", item.type === "separator" && "mx-2", className);
+	if (item.type === "custom") {
+		const CustomComponent = item.component;
+		if (CustomComponent) return /* @__PURE__ */ jsx("div", {
+			className: containerClassName,
+			children: /* @__PURE__ */ jsx(CustomComponent, { ...commonProps })
+		});
+		return null;
+	}
+	const renderer = ToolbarRendererRegistry.get(item.type);
+	if (!renderer) {
+		console.warn(`No renderer registered for toolbar item type: ${item.type}`);
+		return null;
+	}
+	return /* @__PURE__ */ jsx("div", {
+		className: containerClassName,
+		children: renderer(item, commonProps, isMobile)
+	});
+}
+
+//#endregion
+export { ToolbarRenderer, ToolbarRendererRegistry };
+//# sourceMappingURL=ToolbarRenderer.js.map

package/dist/esm/components/data-table/ToolbarRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolbarRenderer.js","names":["filterGroupItem","ComponentSize","useMobileDetection","customItem"],"sources":["../../../../src/components/data-table/ToolbarRenderer.tsx"],"sourcesContent":["import { Button, cn } from \"@lumeweb/portal-framework-ui-core\";\nimport React from \"react\";\nimport { FilterGroup } from \"./toolbarItems/FilterGroup\";\nimport { FilterResolver } from \"./toolbarItems/FilterResolver\";\n\nimport {\n  ExtendedToolbarItem,\n  FilterConfig,\n  ToolbarCustomItem,\n  ToolbarFilterGroupItem,\n  ToolbarFilterItem,\n  ToolbarItemComponentProps,\n  ToolbarItemType,\n} from \"./DataTable.types\";\nimport { BaseRecord } from \"@refinedev/core\";\nimport { getAction } from \"./ToolbarRegistry\";\nimport { useMobileDetection } from \"./useMobileDetection\";\nimport { ComponentSize } from \"@/components\";\n\n// Registry for toolbar item renderers\ntype ToolbarItemRenderer<TData extends BaseRecord> = (\n  item: ExtendedToolbarItem<TData>,\n  commonProps: ToolbarItemComponentProps<TData>,\n) => React.ReactNode;\n\nconst toolbarItemRenderers = new Map<string, ToolbarItemRenderer<any>>();\n\n// Define core supported breakpoints\nconst coreSupported = new Set([\"xs\", \"sm\", \"md\", \"lg\", \"xl\", \"2xl\", \"3xl\", \"4xl\", \"5xl\", \"6xl\", \"7xl\", \"auto\", \"full\"]);\n\n// Internal renderer components\nfunction ActionItemRenderer<TData extends BaseRecord>(\n  item: ExtendedToolbarItem<TData>,\n  commonProps: ToolbarItemComponentProps<TData>,\n  isMobile: boolean,\n) {\n  const actionItem = getAction<TData>(item.id);\n  if (!actionItem) return null;\n\n  // Use mobile size on small screens for better touch targets\n  const buttonSize = isMobile ? \"mobile\" : actionItem.size;\n\n  return (\n    <Button\n      className={actionItem.className}\n      disabled={actionItem.disabled}\n      onClick={() => actionItem.onClick(commonProps)}\n      size={buttonSize}\n      title={actionItem.tooltip}\n      variant={actionItem.variant}>\n      {actionItem.icon && <span className=\"mr-2\">{actionItem.icon}</span>}\n      {actionItem.label}\n    </Button>\n  );\n}\n\nfunction FilterItemRenderer<TData extends BaseRecord>(\n  item: ExtendedToolbarItem<TData>,\n  commonProps: ToolbarItemComponentProps<TData>,\n) {\n  const filterItem = item as ToolbarFilterItem<TData>;\n\n  return (\n    <div className=\"flex flex-col\">\n      <label className=\"text-sm font-medium\">{filterItem.label}</label>\n      <FilterResolver filterItem={filterItem} commonProps={commonProps} />\n    </div>\n  );\n}\n\nfunction FilterGroupItemRenderer<TData extends BaseRecord>(\n  item: ExtendedToolbarItem<TData>,\n  commonProps: ToolbarItemComponentProps<TData>,\n) {\n  const filterGroupItem = item as ToolbarFilterGroupItem<TData>;\n\n  return <FilterGroup item={filterGroupItem} commonProps={commonProps} />;\n}\n\nfunction SeparatorItemRenderer<TData extends BaseRecord>(\n  item: ExtendedToolbarItem<TData>,\n  commonProps: ToolbarItemComponentProps<TData>,\n) {\n  return <div className=\"h-6 w-px bg-gray-300\" />;\n}\n\n// Register default renderers\nfunction registerDefaultRenderers() {\n  // Action item renderer\n  toolbarItemRenderers.set(ToolbarItemType.ACTION, ActionItemRenderer);\n  toolbarItemRenderers.set(ToolbarItemType.FILTER, FilterItemRenderer);\n  toolbarItemRenderers.set(\n    ToolbarItemType.FILTER_GROUP,\n    FilterGroupItemRenderer,\n  );\n\n  // Separator item renderer\n  toolbarItemRenderers.set(ToolbarItemType.SEPARATOR, SeparatorItemRenderer);\n}\n\n// Initialize default renderers\nregisterDefaultRenderers();\n\n// Registry API\nexport const ToolbarRendererRegistry = {\n  /**\n   * Register a custom renderer for a toolbar item type\n   */\n  register<TData extends BaseRecord>(\n    type: string,\n    renderer: ToolbarItemRenderer<TData>,\n  ) {\n    toolbarItemRenderers.set(type, renderer);\n  },\n\n  /**\n   * Get a registered renderer for a toolbar item type\n   */\n  get<TData extends BaseRecord>(\n    type: string,\n  ): ToolbarItemRenderer<TData> | undefined {\n    return toolbarItemRenderers.get(type);\n  },\n\n  /**\n   * Check if a renderer is registered for a type\n   */\n  has(type: string): boolean {\n    return toolbarItemRenderers.has(type);\n  },\n\n  /**\n   * Remove a registered renderer\n   */\n  remove(type: string): boolean {\n    return toolbarItemRenderers.delete(type);\n  },\n\n  /**\n   * Clear all registered renderers\n   */\n  clear() {\n    toolbarItemRenderers.clear();\n    registerDefaultRenderers(); // Re-register defaults\n  },\n\n  list(): string[] {\n    return Array.from(toolbarItemRenderers.keys());\n  },\n};\n\ninterface ToolbarRendererProps<TData extends BaseRecord> {\n  /** The toolbar item to render */\n  item: ExtendedToolbarItem<TData>;\n  /** Common props passed to all toolbar item components */\n  commonProps: ToolbarItemComponentProps<TData>;\n  /** Additional class name for the item container */\n  className?: string;\n}\n\nfunction ToolbarRenderer<TData extends BaseRecord>({\n  item,\n  commonProps,\n  className,\n}: ToolbarRendererProps<TData>) {\n  // Validate mobileBreakpoint value\n  const mobileBreakpoint = commonProps.context?.toolbarConfig?.mobileBreakpoint;\n  const candidate =\n    mobileBreakpoint &&\n    Object.values(ComponentSize).includes(mobileBreakpoint as ComponentSize)\n      ? mobileBreakpoint\n      : ComponentSize.SM;\n\n  const breakpointName =\n    typeof candidate === \"string\" && !coreSupported.has(candidate)\n      ? ComponentSize.SM\n      : candidate;\n\n  // Check if we're on mobile to adjust button sizing\n  const { isMobile } = useMobileDetection({\n    mobileBreakpoint: breakpointName || ComponentSize.SM,\n  });\n\n  const containerClassName = cn(\n    \"flex items-center\",\n    item.type === ToolbarItemType.SEPARATOR && \"mx-2\",\n    className,\n  );\n\n  // Handle CUSTOM type items directly\n  if (item.type === ToolbarItemType.CUSTOM) {\n    const customItem = item as ToolbarCustomItem<TData>;\n    const CustomComponent = customItem.component;\n\n    if (CustomComponent) {\n      return (\n        <div className={containerClassName}>\n          <CustomComponent {...commonProps} />\n        </div>\n      );\n    }\n\n    return null;\n  }\n\n  const renderer = ToolbarRendererRegistry.get<TData>(item.type);\n\n  if (!renderer) {\n    console.warn(`No renderer registered for toolbar item type: ${item.type}`);\n    return null;\n  }\n\n  const renderedItem = renderer(item, commonProps, isMobile);\n\n  return <div className={containerClassName}>{renderedItem}</div>;\n}\n\nexport { ToolbarRenderer };\n"],"mappings":";;;;;;;;;;;;AAyBA,MAAM,uCAAuB,IAAI,KAAuC;AAGxE,MAAM,gBAAgB,IAAI,IAAI;CAAC;CAAM;CAAM;CAAM;CAAM;CAAM;CAAO;CAAO;CAAO;CAAO;CAAO;CAAO;CAAQ;CAAO,CAAC;AAGvH,SAAS,mBACP,MACA,aACA,UACA;CACA,MAAM,aAAa,UAAiB,KAAK,GAAG;AAC5C,KAAI,CAAC,WAAY,QAAO;CAGxB,MAAM,aAAa,WAAW,WAAW,WAAW;AAEpD,QACE,qBAAC,QAAD;EACE,WAAW,WAAW;EACtB,UAAU,WAAW;EACrB,eAAe,WAAW,QAAQ,YAAY;EAC9C,MAAM;EACN,OAAO,WAAW;EAClB,SAAS,WAAW;YANtB,CAOG,WAAW,QAAQ,oBAAC,QAAD;GAAM,WAAU;aAAQ,WAAW;GAAY,GAClE,WAAW,MACL;;;AAIb,SAAS,mBACP,MACA,aACA;CACA,MAAM,aAAa;AAEnB,QACE,qBAAC,OAAD;EAAK,WAAU;YAAf,CACE,oBAAC,SAAD;GAAO,WAAU;aAAuB,WAAW;GAAc,GACjE,oBAAC,gBAAD;GAA4B;GAAyB;GAAe,EAChE;;;AAIV,SAAS,wBACP,MACA,aACA;AAGA,QAAO,oBAAC,aAAD;EAAmBA;EAA8B;EAAe;;AAGzE,SAAS,sBACP,MACA,aACA;AACA,QAAO,oBAAC,OAAD,EAAK,WAAU,wBAAyB;;AAIjD,SAAS,2BAA2B;AAElC,sBAAqB,cAA4B,mBAAmB;AACpE,sBAAqB,cAA4B,mBAAmB;AACpE,sBAAqB,oBAEnB,wBACD;AAGD,sBAAqB,iBAA+B,sBAAsB;;AAI5E,0BAA0B;AAG1B,MAAa,0BAA0B;;;;CAIrC,SACE,MACA,UACA;AACA,uBAAqB,IAAI,MAAM,SAAS;;;;;CAM1C,IACE,MACwC;AACxC,SAAO,qBAAqB,IAAI,KAAK;;;;;CAMvC,IAAI,MAAuB;AACzB,SAAO,qBAAqB,IAAI,KAAK;;;;;CAMvC,OAAO,MAAuB;AAC5B,SAAO,qBAAqB,OAAO,KAAK;;;;;CAM1C,QAAQ;AACN,uBAAqB,OAAO;AAC5B,4BAA0B;;CAG5B,OAAiB;AACf,SAAO,MAAM,KAAK,qBAAqB,MAAM,CAAC;;CAEjD;AAWD,SAAS,gBAA0C,EACjD,MACA,aACA,aAC8B;CAE9B,MAAM,mBAAmB,YAAY,SAAS,eAAe;CAC7D,MAAM,YACJ,oBACA,OAAO,OAAOC,gBAAc,CAAC,SAAS,iBAAkC,GACpE;CASN,MAAM,EAAE,aAAaC,qBAAmB,EACtC,mBANA,OAAO,cAAc,YAAY,CAAC,cAAc,IAAI,UAAU,UAE1D,oBAKL,CAAC;CAEF,MAAM,qBAAqB,GACzB,qBACA,KAAK,wBAAsC,QAC3C,UACD;AAGD,KAAI,KAAK,mBAAiC;EAExC,MAAM,kBAAkBC,KAAW;AAEnC,MAAI,gBACF,QACE,oBAAC,OAAD;GAAK,WAAW;aACd,oBAAC,iBAAD,EAAiB,GAAI,aAAe;GAChC;AAIV,SAAO;;CAGT,MAAM,WAAW,wBAAwB,IAAW,KAAK,KAAK;AAE9D,KAAI,CAAC,UAAU;AACb,UAAQ,KAAK,iDAAiD,KAAK,OAAO;AAC1E,SAAO;;AAKT,QAAO,oBAAC,OAAD;EAAK,WAAW;YAFF,SAAS,MAAM,aAAa,SAEO;EAAO"}

package/dist/esm/components/data-table/contexts/FilterHelpers.d.ts

@@ -0,0 +1,30 @@
+import { FilterOperator } from "../toolbarItems/filters/types.js";
+import { BaseRecord, CrudFilter, CrudOperators } from "@refinedev/core";
+import React from "react";
+
+//#region src/components/data-table/contexts/FilterHelpers.d.ts
+type GetDefaultFilterFn = (columnName: string, operatorType?: CrudOperators) => CrudFilter["value"] | undefined;
+interface FilterHelpersContextValue<TData extends BaseRecord> {
+  getDefaultFilter: GetDefaultFilterFn;
+  getDefaultOperator: (fieldType: string) => string;
+  getAvailableOperators: (fieldType: string) => FilterOperator[];
+}
+interface FilterHelpersProviderProps<TData extends BaseRecord> {
+  children: React.ReactNode;
+  refineTable?: any;
+  getDefaultFilter?: GetDefaultFilterFn;
+  getDefaultOperator?: (fieldType: string) => string;
+  getAvailableOperators?: (fieldType: string) => FilterOperator[];
+}
+declare const useDefaultFilter: <TData extends BaseRecord>(refineTable?: any) => any;
+declare function FilterHelpersProvider<TData extends BaseRecord>({
+  children,
+  refineTable,
+  getDefaultFilter,
+  getDefaultOperator,
+  getAvailableOperators
+}: FilterHelpersProviderProps<TData>): any;
+declare const useFilterHelpers: <TData extends BaseRecord>() => FilterHelpersContextValue<TData>;
+//#endregion
+export { FilterHelpersContextValue, FilterHelpersProvider, FilterHelpersProviderProps, GetDefaultFilterFn, useDefaultFilter, useFilterHelpers };
+//# sourceMappingURL=FilterHelpers.d.ts.map

package/dist/esm/components/data-table/contexts/FilterHelpers.js

@@ -0,0 +1,60 @@
+import { getAvailableOperators, getDefaultOperatorForFieldType } from "../toolbarItems/filters/hooks/useFilterOperators.js";
+import { getDefaultFilter } from "@refinedev/core";
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/data-table/contexts/FilterHelpers.tsx
+const FilterHelpersContext = createContext(void 0);
+const useDefaultFilter = (refineTable) => {
+	const filtersRef = useRef(refineTable?.refineCore?.filters);
+	useEffect(() => {
+		filtersRef.current = refineTable?.refineCore?.filters;
+	}, [refineTable?.refineCore?.filters]);
+	return useCallback((columnName, operatorType = "eq") => {
+		return getDefaultFilter(columnName, filtersRef.current, operatorType);
+	}, []);
+};
+function FilterHelpersProvider({ children, refineTable, getDefaultFilter, getDefaultOperator, getAvailableOperators: getAvailableOperators$1 }) {
+	const defaultGetDefaultFilter = useDefaultFilter(refineTable);
+	const finalGetDefaultFilter = getDefaultFilter || defaultGetDefaultFilter;
+	const defaultGetDefaultOperator = useCallback((fieldType) => {
+		return getDefaultOperatorForFieldType(fieldType);
+	}, []);
+	const finalGetDefaultOperator = getDefaultOperator || defaultGetDefaultOperator;
+	const defaultGetAvailableOperators = useCallback((fieldType) => {
+		return getAvailableOperators(fieldType);
+	}, []);
+	const finalGetAvailableOperators = getAvailableOperators$1 || defaultGetAvailableOperators;
+	const finalGetDefaultFilterRef = useRef(finalGetDefaultFilter);
+	const finalGetDefaultOperatorRef = useRef(finalGetDefaultOperator);
+	const finalGetAvailableOperatorsRef = useRef(finalGetAvailableOperators);
+	useEffect(() => {
+		finalGetDefaultFilterRef.current = finalGetDefaultFilter;
+		finalGetDefaultOperatorRef.current = finalGetDefaultOperator;
+		finalGetAvailableOperatorsRef.current = finalGetAvailableOperators;
+	}, [
+		finalGetDefaultFilter,
+		finalGetDefaultOperator,
+		finalGetAvailableOperators
+	]);
+	const value = useMemo(() => {
+		return {
+			getDefaultFilter: finalGetDefaultFilterRef.current,
+			getDefaultOperator: finalGetDefaultOperatorRef.current,
+			getAvailableOperators: finalGetAvailableOperatorsRef.current
+		};
+	}, []);
+	return /* @__PURE__ */ jsx(FilterHelpersContext.Provider, {
+		value,
+		children
+	});
+}
+const useFilterHelpers = () => {
+	const context = useContext(FilterHelpersContext);
+	if (context === void 0) throw new Error("useFilterHelpers must be used within a FilterHelpersProvider");
+	return context;
+};
+
+//#endregion
+export { FilterHelpersProvider, useDefaultFilter, useFilterHelpers };
+//# sourceMappingURL=FilterHelpers.js.map

package/dist/esm/components/data-table/contexts/FilterHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterHelpers.js","names":["refineGetDefaultFilter","getAvailableOperatorsHelper","getAvailableOperators"],"sources":["../../../../../src/components/data-table/contexts/FilterHelpers.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n} from \"react\";\nimport type { BaseRecord, CrudFilter, CrudOperators } from \"@refinedev/core\";\nimport { getDefaultFilter as refineGetDefaultFilter } from \"@refinedev/core\";\nimport {\n  getDefaultOperatorForFieldType,\n  getAvailableOperators as getAvailableOperatorsHelper,\n} from \"../toolbarItems/filters/hooks/useFilterOperators\";\nimport { FilterOperator } from \"../toolbarItems/filters/types\";\n\nexport type GetDefaultFilterFn = (\n  columnName: string,\n  operatorType?: CrudOperators,\n) => CrudFilter[\"value\"] | undefined;\n\nexport interface FilterHelpersContextValue<TData extends BaseRecord> {\n  getDefaultFilter: GetDefaultFilterFn;\n  getDefaultOperator: (fieldType: string) => string;\n  getAvailableOperators: (fieldType: string) => FilterOperator[];\n}\n\nconst FilterHelpersContext = createContext<FilterHelpersContextValue<any> | undefined>(\n  undefined,\n);\n\nexport interface FilterHelpersProviderProps<TData extends BaseRecord> {\n  children: React.ReactNode;\n  refineTable?: any;\n  getDefaultFilter?: GetDefaultFilterFn;\n  getDefaultOperator?: (fieldType: string) => string;\n  getAvailableOperators?: (fieldType: string) => FilterOperator[];\n}\n\n// Custom hook for getDefaultFilter functionality\nexport const useDefaultFilter = <TData extends BaseRecord>(\n  refineTable?: any,\n) => {\n  // Use ref to track filters to prevent function recreation\n  const filtersRef = useRef(refineTable?.refineCore?.filters);\n\n  // Update ref when filters change\n  useEffect(() => {\n    filtersRef.current = refineTable?.refineCore?.filters;\n  }, [refineTable?.refineCore?.filters]);\n\n  // Stable function that reads from ref\n  return useCallback(\n    (columnName: string, operatorType: CrudOperators = \"eq\") => {\n      const result = refineGetDefaultFilter(\n        columnName,\n        filtersRef.current,\n        operatorType,\n      );\n      \n      return result;\n    },\n    [],\n  );\n};\n\nexport function FilterHelpersProvider<TData extends BaseRecord>({\n  children,\n  refineTable,\n  getDefaultFilter,\n  getDefaultOperator,\n  getAvailableOperators,\n}: FilterHelpersProviderProps<TData>) {\n  // If getDefaultFilter is not provided, create a default one\n  const defaultGetDefaultFilter = useDefaultFilter(refineTable);\n  const finalGetDefaultFilter = getDefaultFilter || defaultGetDefaultFilter;\n\n  // If getDefaultOperator is not provided, create a default one\n  const defaultGetDefaultOperator = useCallback(\n    (fieldType: string): string => {\n      return getDefaultOperatorForFieldType(fieldType);\n    },\n    [],\n  );\n  const finalGetDefaultOperator =\n    getDefaultOperator || defaultGetDefaultOperator;\n\n  const defaultGetAvailableOperators = useCallback(\n    (fieldType: string): FilterOperator[] => {\n      return getAvailableOperatorsHelper(fieldType);\n    },\n    [],\n  );\n  const finalGetAvailableOperators =\n    getAvailableOperators || defaultGetAvailableOperators;\n\n  // Use refs to stabilize references and prevent contexts thrashing\n  const finalGetDefaultFilterRef = useRef(finalGetDefaultFilter);\n  const finalGetDefaultOperatorRef = useRef(finalGetDefaultOperator);\n  const finalGetAvailableOperatorsRef = useRef(finalGetAvailableOperators);\n\n  // Update refs when values change\n  useEffect(() => {\n    finalGetDefaultFilterRef.current = finalGetDefaultFilter;\n    finalGetDefaultOperatorRef.current = finalGetDefaultOperator;\n    finalGetAvailableOperatorsRef.current = finalGetAvailableOperators;\n  }, [finalGetDefaultFilter, finalGetDefaultOperator, finalGetAvailableOperators]);\n\n  // Create stable context value using refs\n  const value = useMemo(() => {\n    return {\n      getDefaultFilter: finalGetDefaultFilterRef.current,\n      getDefaultOperator: finalGetDefaultOperatorRef.current,\n      getAvailableOperators: finalGetAvailableOperatorsRef.current,\n    };\n  }, []);\n\n  return (\n    <FilterHelpersContext.Provider value={value}>\n      {children}\n    </FilterHelpersContext.Provider>\n  );\n}\n\nexport const useFilterHelpers = <TData extends BaseRecord>() => {\n  const context = useContext(FilterHelpersContext);\n  if (context === undefined) {\n    throw new Error(\"useFilterHelpers must be used within a FilterHelpersProvider\");\n  }\n  return context as FilterHelpersContextValue<TData>;\n};\n"],"mappings":";;;;;;AA2BA,MAAM,uBAAuB,cAC3B,OACD;AAWD,MAAa,oBACX,gBACG;CAEH,MAAM,aAAa,OAAO,aAAa,YAAY,QAAQ;AAG3D,iBAAgB;AACd,aAAW,UAAU,aAAa,YAAY;IAC7C,CAAC,aAAa,YAAY,QAAQ,CAAC;AAGtC,QAAO,aACJ,YAAoB,eAA8B,SAAS;AAO1D,SANeA,iBACb,YACA,WAAW,SACX,aAGW;IAEf,EAAE,CACH;;AAGH,SAAgB,sBAAgD,EAC9D,UACA,aACA,kBACA,oBACA,kDACoC;CAEpC,MAAM,0BAA0B,iBAAiB,YAAY;CAC7D,MAAM,wBAAwB,oBAAoB;CAGlD,MAAM,4BAA4B,aAC/B,cAA8B;AAC7B,SAAO,+BAA+B,UAAU;IAElD,EAAE,CACH;CACD,MAAM,0BACJ,sBAAsB;CAExB,MAAM,+BAA+B,aAClC,cAAwC;AACvC,SAAOC,sBAA4B,UAAU;IAE/C,EAAE,CACH;CACD,MAAM,6BACJC,2BAAyB;CAG3B,MAAM,2BAA2B,OAAO,sBAAsB;CAC9D,MAAM,6BAA6B,OAAO,wBAAwB;CAClE,MAAM,gCAAgC,OAAO,2BAA2B;AAGxE,iBAAgB;AACd,2BAAyB,UAAU;AACnC,6BAA2B,UAAU;AACrC,gCAA8B,UAAU;IACvC;EAAC;EAAuB;EAAyB;EAA2B,CAAC;CAGhF,MAAM,QAAQ,cAAc;AAC1B,SAAO;GACL,kBAAkB,yBAAyB;GAC3C,oBAAoB,2BAA2B;GAC/C,uBAAuB,8BAA8B;GACtD;IACA,EAAE,CAAC;AAEN,QACE,oBAAC,qBAAqB,UAAtB;EAAsC;EACnC;EAC6B;;AAIpC,MAAa,yBAAmD;CAC9D,MAAM,UAAU,WAAW,qBAAqB;AAChD,KAAI,YAAY,OACd,OAAM,IAAI,MAAM,+DAA+D;AAEjF,QAAO"}

package/dist/esm/components/data-table/contexts/RefineTable.d.ts

@@ -0,0 +1,25 @@
+import { BaseRecord } from "@refinedev/core";
+import React from "react";
+import { UseTableReturnType } from "@refinedev/react-table";
+
+//#region src/components/data-table/contexts/RefineTable.d.ts
+interface RefineTableContextValue<TData extends BaseRecord> {
+  refineTable?: UseTableReturnType<TData, any>;
+  setFilters?: UseTableReturnType<TData, any>["refineCore"]["setFilters"];
+  setSorters?: UseTableReturnType<TData, any>["refineCore"]["setSorters"];
+  tableQuery?: any;
+  filters?: any;
+  sorters?: any;
+}
+interface RefineTableProviderProps<TData extends BaseRecord> {
+  children: React.ReactNode;
+  refineTable?: UseTableReturnType<TData, any>;
+}
+declare function RefineTableProvider<TData extends BaseRecord>({
+  children,
+  refineTable
+}: RefineTableProviderProps<TData>): any;
+declare const useRefineTable: <TData extends BaseRecord>() => RefineTableContextValue<TData>;
+//#endregion
+export { RefineTableContextValue, RefineTableProvider, RefineTableProviderProps, useRefineTable };
+//# sourceMappingURL=RefineTable.d.ts.map

package/dist/esm/components/data-table/contexts/RefineTable.js

@@ -0,0 +1,69 @@
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import deepEqual from "fast-deep-equal";
+
+//#region src/components/data-table/contexts/RefineTable.tsx
+const RefineTableContext = createContext(void 0);
+function RefineTableProvider({ children, refineTable }) {
+	const [version, setVersion] = useState(0);
+	const refineTableRef = useRef(refineTable);
+	const setFiltersRef = useRef(refineTable?.refineCore?.setFilters);
+	const setSortersRef = useRef(refineTable?.refineCore?.setSorters);
+	const tableQueryRef = useRef(refineTable?.refineCore?.tableQuery);
+	const filtersRef = useRef(refineTable?.refineCore?.filters);
+	const sortersRef = useRef(refineTable?.refineCore?.sorters);
+	const prevFiltersRef = useRef(refineTable?.refineCore?.filters);
+	const prevSortersRef = useRef(refineTable?.refineCore?.sorters);
+	useEffect(() => {
+		let hasChanges = false;
+		if (refineTable?.refineCore?.setFilters !== setFiltersRef.current) {
+			setFiltersRef.current = refineTable?.refineCore?.setFilters;
+			hasChanges = true;
+		}
+		if (refineTable?.refineCore?.setSorters !== setSortersRef.current) {
+			setSortersRef.current = refineTable?.refineCore?.setSorters;
+			hasChanges = true;
+		}
+		const newFilters = refineTable?.refineCore?.filters || [];
+		if (!deepEqual(prevFiltersRef.current, newFilters)) {
+			filtersRef.current = newFilters;
+			prevFiltersRef.current = newFilters;
+			hasChanges = true;
+		}
+		const newSorters = refineTable?.refineCore?.sorters || [];
+		if (!deepEqual(prevSortersRef.current, newSorters)) {
+			sortersRef.current = newSorters;
+			prevSortersRef.current = newSorters;
+			hasChanges = true;
+		}
+		const prevRefineTable = refineTableRef.current;
+		const prevTableQuery = tableQueryRef.current;
+		refineTableRef.current = refineTable;
+		tableQueryRef.current = refineTable?.refineCore?.tableQuery;
+		if (prevRefineTable !== refineTable || prevTableQuery !== refineTable?.refineCore?.tableQuery) hasChanges = true;
+		if (hasChanges) setVersion((v) => v + 1);
+	}, [refineTable]);
+	const value = useMemo(() => {
+		return {
+			refineTable: refineTableRef.current,
+			setFilters: setFiltersRef.current,
+			setSorters: setSortersRef.current,
+			tableQuery: tableQueryRef.current,
+			filters: filtersRef.current,
+			sorters: sortersRef.current
+		};
+	}, [version]);
+	return /* @__PURE__ */ jsx(RefineTableContext.Provider, {
+		value,
+		children
+	});
+}
+const useRefineTable = () => {
+	const context = useContext(RefineTableContext);
+	if (context === void 0) throw new Error("useRefineTable must be used within a RefineTableProvider");
+	return context;
+};
+
+//#endregion
+export { RefineTableProvider, useRefineTable };
+//# sourceMappingURL=RefineTable.js.map

package/dist/esm/components/data-table/contexts/RefineTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefineTable.js","names":[],"sources":["../../../../../src/components/data-table/contexts/RefineTable.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport type { UseTableReturnType } from \"@refinedev/react-table\";\nimport type { BaseRecord } from \"@refinedev/core\";\nimport deepEqual from \"fast-deep-equal\";\n\nexport interface RefineTableContextValue<TData extends BaseRecord> {\n  refineTable?: UseTableReturnType<TData, any>;\n  setFilters?: UseTableReturnType<TData, any>[\"refineCore\"][\"setFilters\"];\n  setSorters?: UseTableReturnType<TData, any>[\"refineCore\"][\"setSorters\"];\n  tableQuery?: any;\n  filters?: any;\n  sorters?: any;\n}\n\nconst RefineTableContext = createContext<\n  RefineTableContextValue<any> | undefined\n>(undefined);\n\nexport interface RefineTableProviderProps<TData extends BaseRecord> {\n  children: React.ReactNode;\n  refineTable?: UseTableReturnType<TData, any>;\n}\n\nexport function RefineTableProvider<TData extends BaseRecord>({\n  children,\n  refineTable,\n}: RefineTableProviderProps<TData>) {\n  const [version, setVersion] = useState(0);\n\n  // Use refs to stabilize references and prevent contexts thrashing\n  const refineTableRef = useRef(refineTable);\n  const setFiltersRef = useRef(refineTable?.refineCore?.setFilters);\n  const setSortersRef = useRef(refineTable?.refineCore?.setSorters);\n  const tableQueryRef = useRef(refineTable?.refineCore?.tableQuery);\n  const filtersRef = useRef(refineTable?.refineCore?.filters);\n  const sortersRef = useRef(refineTable?.refineCore?.sorters);\n\n  // Track previous values for deep comparison\n  const prevFiltersRef = useRef(refineTable?.refineCore?.filters);\n  const prevSortersRef = useRef(refineTable?.refineCore?.sorters);\n\n  // Update refs when values change (only update if actual data changed)\n  useEffect(() => {\n    let hasChanges = false;\n\n    // Update function refs if they've changed\n    if (refineTable?.refineCore?.setFilters !== setFiltersRef.current) {\n      setFiltersRef.current = refineTable?.refineCore?.setFilters;\n      hasChanges = true;\n    }\n\n    if (refineTable?.refineCore?.setSorters !== setSortersRef.current) {\n      setSortersRef.current = refineTable?.refineCore?.setSorters;\n      hasChanges = true;\n    }\n\n    // Deep compare filters to prevent false positives\n    const newFilters = refineTable?.refineCore?.filters || [];\n    const filtersChanged = !deepEqual(prevFiltersRef.current, newFilters);\n\n    if (filtersChanged) {\n      filtersRef.current = newFilters;\n      prevFiltersRef.current = newFilters;\n      hasChanges = true;\n    }\n\n    // Deep compare sorters to prevent false positives\n    const newSorters = refineTable?.refineCore?.sorters || [];\n    const sortersChanged = !deepEqual(prevSortersRef.current, newSorters);\n\n    if (sortersChanged) {\n      sortersRef.current = newSorters;\n      prevSortersRef.current = newSorters;\n      hasChanges = true;\n    }\n\n    // Always update these refs as they may change reference without content change\n    const prevRefineTable = refineTableRef.current;\n    const prevTableQuery = tableQueryRef.current;\n    refineTableRef.current = refineTable;\n    tableQueryRef.current = refineTable?.refineCore?.tableQuery;\n    if (prevRefineTable !== refineTable || prevTableQuery !== refineTable?.refineCore?.tableQuery) {\n      hasChanges = true;\n    }\n\n    // Signal that refs have been updated only if changes occurred\n    if (hasChanges) {\n      setVersion((v) => v + 1);\n    }\n  }, [refineTable]);\n\n  // Create stable context value that only changes when refs are updated\n  const value = useMemo(() => {\n    return {\n      refineTable: refineTableRef.current,\n      setFilters: setFiltersRef.current,\n      setSorters: setSortersRef.current,\n      tableQuery: tableQueryRef.current,\n      filters: filtersRef.current,\n      sorters: sortersRef.current,\n    };\n  }, [version]);\n\n  return (\n    <RefineTableContext.Provider value={value}>\n      {children}\n    </RefineTableContext.Provider>\n  );\n}\n\nexport const useRefineTable = <TData extends BaseRecord>() => {\n  const context = useContext(RefineTableContext);\n\n  if (context === undefined) {\n    throw new Error(\"useRefineTable must be used within a RefineTableProvider\");\n  }\n\n  return context as RefineTableContextValue<TData>;\n};\n"],"mappings":";;;;;AAqBA,MAAM,qBAAqB,cAEzB,OAAU;AAOZ,SAAgB,oBAA8C,EAC5D,UACA,eACkC;CAClC,MAAM,CAAC,SAAS,cAAc,SAAS,EAAE;CAGzC,MAAM,iBAAiB,OAAO,YAAY;CAC1C,MAAM,gBAAgB,OAAO,aAAa,YAAY,WAAW;CACjE,MAAM,gBAAgB,OAAO,aAAa,YAAY,WAAW;CACjE,MAAM,gBAAgB,OAAO,aAAa,YAAY,WAAW;CACjE,MAAM,aAAa,OAAO,aAAa,YAAY,QAAQ;CAC3D,MAAM,aAAa,OAAO,aAAa,YAAY,QAAQ;CAG3D,MAAM,iBAAiB,OAAO,aAAa,YAAY,QAAQ;CAC/D,MAAM,iBAAiB,OAAO,aAAa,YAAY,QAAQ;AAG/D,iBAAgB;EACd,IAAI,aAAa;AAGjB,MAAI,aAAa,YAAY,eAAe,cAAc,SAAS;AACjE,iBAAc,UAAU,aAAa,YAAY;AACjD,gBAAa;;AAGf,MAAI,aAAa,YAAY,eAAe,cAAc,SAAS;AACjE,iBAAc,UAAU,aAAa,YAAY;AACjD,gBAAa;;EAIf,MAAM,aAAa,aAAa,YAAY,WAAW,EAAE;AAGzD,MAAI,CAFoB,UAAU,eAAe,SAAS,WAAW,EAEjD;AAClB,cAAW,UAAU;AACrB,kBAAe,UAAU;AACzB,gBAAa;;EAIf,MAAM,aAAa,aAAa,YAAY,WAAW,EAAE;AAGzD,MAAI,CAFoB,UAAU,eAAe,SAAS,WAAW,EAEjD;AAClB,cAAW,UAAU;AACrB,kBAAe,UAAU;AACzB,gBAAa;;EAIf,MAAM,kBAAkB,eAAe;EACvC,MAAM,iBAAiB,cAAc;AACrC,iBAAe,UAAU;AACzB,gBAAc,UAAU,aAAa,YAAY;AACjD,MAAI,oBAAoB,eAAe,mBAAmB,aAAa,YAAY,WACjF,cAAa;AAIf,MAAI,WACF,aAAY,MAAM,IAAI,EAAE;IAEzB,CAAC,YAAY,CAAC;CAGjB,MAAM,QAAQ,cAAc;AAC1B,SAAO;GACL,aAAa,eAAe;GAC5B,YAAY,cAAc;GAC1B,YAAY,cAAc;GAC1B,YAAY,cAAc;GAC1B,SAAS,WAAW;GACpB,SAAS,WAAW;GACrB;IACA,CAAC,QAAQ,CAAC;AAEb,QACE,oBAAC,mBAAmB,UAApB;EAAoC;EACjC;EAC2B;;AAIlC,MAAa,uBAAiD;CAC5D,MAAM,UAAU,WAAW,mBAAmB;AAE9C,KAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAG7E,QAAO"}

package/dist/esm/components/data-table/contexts/TableConfig.d.ts

@@ -0,0 +1,24 @@
+import { ToolbarConfig, ToolbarRefineContext } from "../DataTable.types.js";
+import { BaseRecord } from "@refinedev/core";
+import React from "react";
+
+//#region src/components/data-table/contexts/TableConfig.d.ts
+interface TableConfigContextValue<TData extends BaseRecord> {
+  toolbarConfig?: ToolbarConfig<TData>;
+  refineContext?: ToolbarRefineContext<TData>;
+}
+interface TableConfigProviderProps<TData extends BaseRecord> {
+  children: React.ReactNode;
+  toolbarConfig?: ToolbarConfig<TData>;
+  refineContext?: ToolbarRefineContext<TData>;
+}
+declare function TableConfigProvider<TData extends BaseRecord>({
+  children,
+  toolbarConfig,
+  refineContext
+}: TableConfigProviderProps<TData>): any;
+declare const useTableConfig: <TData extends BaseRecord>() => TableConfigContextValue<TData>;
+declare const useTableConfigOptional: <TData extends BaseRecord>() => TableConfigContextValue<TData> | undefined;
+//#endregion
+export { TableConfigContextValue, TableConfigProvider, TableConfigProviderProps, useTableConfig, useTableConfigOptional };
+//# sourceMappingURL=TableConfig.d.ts.map

package/dist/esm/components/data-table/contexts/TableConfig.js

@@ -0,0 +1,29 @@
+import React, { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/data-table/contexts/TableConfig.tsx
+const TableConfigContext = createContext(void 0);
+function TableConfigProvider({ children, toolbarConfig, refineContext }) {
+	const value = useMemo(() => {
+		return {
+			toolbarConfig,
+			refineContext
+		};
+	}, [toolbarConfig, refineContext]);
+	return /* @__PURE__ */ jsx(TableConfigContext.Provider, {
+		value,
+		children
+	});
+}
+const useTableConfig = () => {
+	const context = useContext(TableConfigContext);
+	if (context === void 0) throw new Error("useTableConfig must be used within a TableConfigProvider");
+	return context;
+};
+const useTableConfigOptional = () => {
+	return useContext(TableConfigContext);
+};
+
+//#endregion
+export { TableConfigProvider, useTableConfig, useTableConfigOptional };
+//# sourceMappingURL=TableConfig.js.map

package/dist/esm/components/data-table/contexts/TableConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableConfig.js","names":[],"sources":["../../../../../src/components/data-table/contexts/TableConfig.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useContext,\n  useMemo,\n} from \"react\";\nimport type { BaseRecord } from \"@refinedev/core\";\nimport { ToolbarConfig, ToolbarRefineContext } from \"../DataTable.types\";\n\nexport interface TableConfigContextValue<TData extends BaseRecord> {\n  toolbarConfig?: ToolbarConfig<TData>;\n  refineContext?: ToolbarRefineContext<TData>;\n}\n\nconst TableConfigContext = createContext<TableConfigContextValue<any> | undefined>(\n  undefined,\n);\n\nexport interface TableConfigProviderProps<TData extends BaseRecord> {\n  children: React.ReactNode;\n  toolbarConfig?: ToolbarConfig<TData>;\n  refineContext?: ToolbarRefineContext<TData>;\n}\n\nexport function TableConfigProvider<TData extends BaseRecord>({\n  children,\n  toolbarConfig,\n  refineContext,\n}: TableConfigProviderProps<TData>) {\n  const value = useMemo(() => {\n    return {\n      toolbarConfig,\n      refineContext,\n    };\n  }, [toolbarConfig, refineContext]);\n\n  return (\n    <TableConfigContext.Provider value={value}>\n      {children}\n    </TableConfigContext.Provider>\n  );\n}\n\nexport const useTableConfig = <TData extends BaseRecord>() => {\n  const context = useContext(TableConfigContext);\n  if (context === undefined) {\n    throw new Error(\"useTableConfig must be used within a TableConfigProvider\");\n  }\n  return context as TableConfigContextValue<TData>;\n};\n\nexport const useTableConfigOptional = <TData extends BaseRecord>() => {\n  const context = useContext(TableConfigContext);\n  return context as TableConfigContextValue<TData> | undefined;\n};\n"],"mappings":";;;;AAaA,MAAM,qBAAqB,cACzB,OACD;AAQD,SAAgB,oBAA8C,EAC5D,UACA,eACA,iBACkC;CAClC,MAAM,QAAQ,cAAc;AAC1B,SAAO;GACL;GACA;GACD;IACA,CAAC,eAAe,cAAc,CAAC;AAElC,QACE,oBAAC,mBAAmB,UAApB;EAAoC;EACjC;EAC2B;;AAIlC,MAAa,uBAAiD;CAC5D,MAAM,UAAU,WAAW,mBAAmB;AAC9C,KAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAE7E,QAAO;;AAGT,MAAa,+BAAyD;AAEpE,QADgB,WAAW,mBACb"}

package/dist/esm/components/data-table/contexts/TableInstance.d.ts

@@ -0,0 +1,20 @@
+import { BaseRecord } from "@refinedev/core";
+import React from "react";
+import { Table } from "@tanstack/react-table";
+
+//#region src/components/data-table/contexts/TableInstance.d.ts
+interface TableInstanceContextValue<TData extends BaseRecord> {
+  table: Table<TData>;
+}
+interface TableInstanceProviderProps<TData extends BaseRecord> {
+  children: React.ReactNode;
+  table: Table<TData>;
+}
+declare function TableInstanceProvider<TData extends BaseRecord>({
+  children,
+  table
+}: TableInstanceProviderProps<TData>): any;
+declare const useTableInstance: <TData extends BaseRecord>() => TableInstanceContextValue<TData>;
+//#endregion
+export { TableInstanceContextValue, TableInstanceProvider, TableInstanceProviderProps, useTableInstance };
+//# sourceMappingURL=TableInstance.d.ts.map

package/dist/esm/components/data-table/contexts/TableInstance.js

@@ -0,0 +1,21 @@
+import React, { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/data-table/contexts/TableInstance.tsx
+const TableInstanceContext = createContext(void 0);
+function TableInstanceProvider({ children, table }) {
+	const value = { table };
+	return /* @__PURE__ */ jsx(TableInstanceContext.Provider, {
+		value,
+		children
+	});
+}
+const useTableInstance = () => {
+	const context = useContext(TableInstanceContext);
+	if (context === void 0) throw new Error("useTableInstance must be used within a TableInstanceProvider");
+	return context;
+};
+
+//#endregion
+export { TableInstanceProvider, useTableInstance };
+//# sourceMappingURL=TableInstance.js.map

package/dist/esm/components/data-table/contexts/TableInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableInstance.js","names":[],"sources":["../../../../../src/components/data-table/contexts/TableInstance.tsx"],"sourcesContent":["import { Table } from \"@tanstack/react-table\";\nimport React, {\n  createContext,\n  useContext,\n} from \"react\";\nimport type { BaseRecord } from \"@refinedev/core\";\n\nexport interface TableInstanceContextValue<TData extends BaseRecord> {\n  table: Table<TData>;\n}\n\nconst TableInstanceContext = createContext<\n  TableInstanceContextValue<any> | undefined\n>(undefined);\n\nexport interface TableInstanceProviderProps<TData extends BaseRecord> {\n  children: React.ReactNode;\n  table: Table<TData>;\n}\n\nexport function TableInstanceProvider<TData extends BaseRecord>({\n  children,\n  table,\n}: TableInstanceProviderProps<TData>) {\n  const value = {\n    table,\n  };\n\n  return (\n    <TableInstanceContext.Provider value={value}>\n      {children}\n    </TableInstanceContext.Provider>\n  );\n}\n\nexport const useTableInstance = <TData extends BaseRecord>() => {\n  const context = useContext(TableInstanceContext);\n  if (context === undefined) {\n    throw new Error(\n      \"useTableInstance must be used within a TableInstanceProvider\",\n    );\n  }\n  return context as TableInstanceContextValue<TData>;\n};\n"],"mappings":";;;;AAWA,MAAM,uBAAuB,cAE3B,OAAU;AAOZ,SAAgB,sBAAgD,EAC9D,UACA,SACoC;CACpC,MAAM,QAAQ,EACZ,OACD;AAED,QACE,oBAAC,qBAAqB,UAAtB;EAAsC;EACnC;EAC6B;;AAIpC,MAAa,yBAAmD;CAC9D,MAAM,UAAU,WAAW,qBAAqB;AAChD,KAAI,YAAY,OACd,OAAM,IAAI,MACR,+DACD;AAEH,QAAO"}

package/dist/esm/components/data-table/contexts/index.d.ts

@@ -0,0 +1,5 @@
+import { FilterHelpersContextValue, FilterHelpersProvider, FilterHelpersProviderProps, GetDefaultFilterFn, useDefaultFilter, useFilterHelpers } from "./FilterHelpers.js";
+import { RefineTableContextValue, RefineTableProvider, RefineTableProviderProps, useRefineTable } from "./RefineTable.js";
+import { TableConfigContextValue, TableConfigProvider, TableConfigProviderProps, useTableConfig, useTableConfigOptional } from "./TableConfig.js";
+import { TableInstanceContextValue, TableInstanceProvider, TableInstanceProviderProps, useTableInstance } from "./TableInstance.js";
+export { FilterHelpersContextValue, FilterHelpersProvider, FilterHelpersProviderProps, GetDefaultFilterFn, RefineTableContextValue, RefineTableProvider, RefineTableProviderProps, TableConfigContextValue, TableConfigProvider, TableConfigProviderProps, TableInstanceContextValue, TableInstanceProvider, TableInstanceProviderProps, useDefaultFilter, useFilterHelpers, useRefineTable, useTableConfig, useTableConfigOptional, useTableInstance };

package/dist/esm/components/data-table/contexts/index.js

@@ -0,0 +1,6 @@
+import { FilterHelpersProvider, useDefaultFilter, useFilterHelpers } from "./FilterHelpers.js";
+import { RefineTableProvider, useRefineTable } from "./RefineTable.js";
+import { TableConfigProvider, useTableConfig, useTableConfigOptional } from "./TableConfig.js";
+import { TableInstanceProvider, useTableInstance } from "./TableInstance.js";
+
+export { FilterHelpersProvider, RefineTableProvider, TableConfigProvider, TableInstanceProvider, useDefaultFilter, useFilterHelpers, useRefineTable, useTableConfig, useTableConfigOptional, useTableInstance };

package/dist/esm/components/data-table/filterColumnsForMobile.d.ts

@@ -0,0 +1,16 @@
+import { BaseRecord } from "@refinedev/core";
+import { ColumnDef } from "@tanstack/react-table";
+
+//#region src/components/data-table/filterColumnsForMobile.d.ts
+/**
+ * Filters columns for mobile display by adding responsive hiding classes
+ * to specified columns while preserving order and functionality
+ *
+ * @param columns - Array of column definitions
+ * @param hideColumnsOnMobile - Array of column IDs to hide on mobile
+ * @returns Filtered array of column definitions with responsive CSS classes
+ */
+declare function filterColumnsForMobile<TData extends BaseRecord>(columns: ColumnDef<TData>[], hideColumnsOnMobile?: string[]): ColumnDef<TData>[];
+//#endregion
+export { filterColumnsForMobile };
+//# sourceMappingURL=filterColumnsForMobile.d.ts.map

package/dist/esm/components/data-table/filterColumnsForMobile.js

@@ -0,0 +1,31 @@
+//#region src/components/data-table/filterColumnsForMobile.ts
+/**
+* Filters columns for mobile display by adding responsive hiding classes
+* to specified columns while preserving order and functionality
+* 
+* @param columns - Array of column definitions
+* @param hideColumnsOnMobile - Array of column IDs to hide on mobile
+* @returns Filtered array of column definitions with responsive CSS classes
+*/
+function filterColumnsForMobile(columns, hideColumnsOnMobile = []) {
+	if (!hideColumnsOnMobile.length) return columns;
+	return columns.map((column) => {
+		if (hideColumnsOnMobile.includes(column.id)) {
+			const existingClassName = column.meta?.headerClassName || "";
+			const existingCellClassName = column.meta?.cellClassName || "";
+			return {
+				...column,
+				meta: {
+					...column.meta,
+					headerClassName: `${existingClassName} hidden sm:table-cell`.trim(),
+					cellClassName: `${existingCellClassName} hidden sm:table-cell`.trim()
+				}
+			};
+		}
+		return column;
+	});
+}
+
+//#endregion
+export { filterColumnsForMobile };
+//# sourceMappingURL=filterColumnsForMobile.js.map

package/dist/esm/components/data-table/filterColumnsForMobile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterColumnsForMobile.js","names":[],"sources":["../../../../src/components/data-table/filterColumnsForMobile.ts"],"sourcesContent":["import { ColumnDef } from \"@tanstack/react-table\";\nimport { BaseRecord } from \"@refinedev/core\";\n\n/**\n * Filters columns for mobile display by adding responsive hiding classes\n * to specified columns while preserving order and functionality\n * \n * @param columns - Array of column definitions\n * @param hideColumnsOnMobile - Array of column IDs to hide on mobile\n * @returns Filtered array of column definitions with responsive CSS classes\n */\nfunction filterColumnsForMobile<TData extends BaseRecord>(\n  columns: ColumnDef<TData>[],\n  hideColumnsOnMobile: string[] = []\n): ColumnDef<TData>[] {\n  if (!hideColumnsOnMobile.length) {\n    return columns;\n  }\n\n  return columns.map(column => {\n    // Check if this column should be hidden on mobile\n    if (hideColumnsOnMobile.includes(column.id as string)) {\n      // Add responsive hiding classes while preserving existing ones\n      const existingClassName = column.meta?.headerClassName || '';\n      const existingCellClassName = column.meta?.cellClassName || '';\n      \n      return {\n        ...column,\n        meta: {\n          ...column.meta,\n          headerClassName: `${existingClassName} hidden sm:table-cell`.trim(),\n          cellClassName: `${existingCellClassName} hidden sm:table-cell`.trim(),\n        }\n      };\n    }\n    \n    // Return column unchanged if not in hide list\n    return column;\n  });\n}\n\nexport { filterColumnsForMobile };\n"],"mappings":";;;;;;;;;AAWA,SAAS,uBACP,SACA,sBAAgC,EAAE,EACd;AACpB,KAAI,CAAC,oBAAoB,OACvB,QAAO;AAGT,QAAO,QAAQ,KAAI,WAAU;AAE3B,MAAI,oBAAoB,SAAS,OAAO,GAAa,EAAE;GAErD,MAAM,oBAAoB,OAAO,MAAM,mBAAmB;GAC1D,MAAM,wBAAwB,OAAO,MAAM,iBAAiB;AAE5D,UAAO;IACL,GAAG;IACH,MAAM;KACJ,GAAG,OAAO;KACV,iBAAiB,GAAG,kBAAkB,uBAAuB,MAAM;KACnE,eAAe,GAAG,sBAAsB,uBAAuB,MAAM;KACtE;IACF;;AAIH,SAAO;GACP"}

package/dist/esm/components/data-table/index.d.ts

@@ -0,0 +1,50 @@
+import { TableAction, TableActionItem } from "./TableAction.js";
+import { TableActionMenu, TableActionMenuItem } from "./TableActionMenu.js";
+import { ActionType, BaseFilterComponentProps, FilterComponentProps, FilterConfig, FilterOperator, FilterType, LogicalFilterOperator, SelectOption } from "./toolbarItems/filters/types.js";
+import { BaseToolbarItem, DataTableActionMenuProps, DataTableProps, ExtendedToolbarItem, TableContext, TableLayoutType, ToolbarActionItem, ToolbarConfig, ToolbarCustomItem, ToolbarFilterComponentProps, ToolbarFilterGroupItem, ToolbarFilterItem, ToolbarItem, ToolbarItemAlignment, ToolbarItemComponentProps, ToolbarItemType, ToolbarRefineContext, ToolbarSeparatorItem } from "./DataTable.types.js";
+import { ActionColumnCellProps, ActionColumnDef, BaseTable, BaseTableCommonProps, BaseTableCommonPropsType, BaseTableLayoutPropsBase, BaseTablePaginationConfig, BaseTableProps, BaseTableRefineProps, BaseTableWithDataProps, BaseTableWithTableProps, TableDataProps, TableHeaderFooterProps, TableInstanceProps, TableInteractionProps, TablePaginationConfigProps, TablePaginationProps, TableResponsiveProps, TableStateProps, TableStylingProps } from "./BaseTable.js";
+import { BaseTableContent, BaseTableContentProps } from "./BaseTableContent.js";
+import { BaseTableInner } from "./BaseTableInner.js";
+import { DataTable } from "./DataTable.js";
+import { DataTableController, DataTableControllerProps, TableControls } from "./DataTableController.js";
+import { DefaultPagination } from "./DefaultPagination.js";
+import { TableEmptyState, TableEmptyStateProps } from "./EmptyState.js";
+import { TableLoadingState, TableLoadingStateProps } from "./LoadingState.js";
+import { FilterHelpersContextValue, FilterHelpersProvider, FilterHelpersProviderProps, GetDefaultFilterFn, useDefaultFilter, useFilterHelpers } from "./contexts/FilterHelpers.js";
+import { RefineTableContextValue, RefineTableProvider, RefineTableProviderProps, useRefineTable } from "./contexts/RefineTable.js";
+import { TableConfigContextValue, TableConfigProvider, TableConfigProviderProps, useTableConfig, useTableConfigOptional } from "./contexts/TableConfig.js";
+import { TableInstanceContextValue, TableInstanceProvider, TableInstanceProviderProps, useTableInstance } from "./contexts/TableInstance.js";
+import { NormalizedTableOptions, normalizeTableOptions } from "./tableOptions.js";
+import { RegisteredActionItem, RegisteredFilterItem, clear, getAction, getFilter, hasAction, hasFilter, listActions, listAll, listFilters, registerAction, registerFilter, removeAction, removeFilter } from "./ToolbarRegistry.js";
+import { Toolbar } from "./Toolbar.js";
+import { ToolbarRenderer, ToolbarRendererRegistry } from "./ToolbarRenderer.js";
+import { BooleanFilter } from "./toolbarItems/filters/components/BooleanFilter.js";
+import { DateFilter } from "./toolbarItems/filters/components/DateFilter.js";
+import { MultiSelectFilter, MultiSelectFilterProps } from "./toolbarItems/filters/components/MultiSelectFilter.js";
+import { NumberFilter } from "./toolbarItems/filters/components/NumberFilter.js";
+import { RangeFilter, RangeValue } from "./toolbarItems/filters/components/RangeFilter.js";
+import { SearchFilter } from "./toolbarItems/filters/components/SearchFilter.js";
+import { SelectFilter } from "./toolbarItems/filters/components/SelectFilter.js";
+import { TextFilter } from "./toolbarItems/filters/components/TextFilter.js";
+import { createFilterOnChangeHandler, createFiltersFromValue } from "./toolbarItems/filters/util.js";
+import { registerRefreshToolbarItem } from "./toolbarItems/items/refresh.js";
+import { registerSearchToolbarItem } from "./toolbarItems/items/search.js";
+import { ToolbarSeparatorItemComponent, registerSeparatorToolbarItem } from "./toolbarItems/items/separator.js";
+import { ToolbarCustomItemComponent, registerCustomToolbarItem } from "./toolbarItems/items/custom.js";
+import { FilterGroup } from "./toolbarItems/FilterGroup.js";
+import { Cell, ColumnDef, Row, RowData } from "@tanstack/react-table";
+
+//#region src/components/data-table/index.d.ts
+declare module "@tanstack/react-table" {
+  interface ColumnMeta<TData extends RowData, TValue> {
+    /** Class name for data cells */
+    cellClassName?: string;
+    /** Class name for header cells */
+    headerClassName?: string;
+    /** Fixed width for the column (number in px or string) */
+    size?: number | string;
+  }
+}
+//#endregion
+export { ActionColumnCellProps, ActionColumnDef, ActionType, BaseFilterComponentProps, BaseTable, BaseTableCommonProps, BaseTableCommonPropsType, BaseTableContent, BaseTableContentProps, BaseTableInner, BaseTableLayoutPropsBase, BaseTablePaginationConfig, BaseTableProps, BaseTableRefineProps, BaseTableWithDataProps, BaseTableWithTableProps, BaseToolbarItem, BooleanFilter, type Cell, type ColumnDef, DataTable, DataTableActionMenuProps, DataTableController, DataTableControllerProps, DataTableProps, DateFilter, DefaultPagination, ExtendedToolbarItem, FilterComponentProps, FilterConfig, FilterGroup, FilterHelpersContextValue, FilterHelpersProvider, FilterHelpersProviderProps, FilterOperator, FilterType, GetDefaultFilterFn, LogicalFilterOperator, MultiSelectFilter, MultiSelectFilterProps, NormalizedTableOptions, NumberFilter, RangeFilter, RangeValue, RefineTableContextValue, RefineTableProvider, RefineTableProviderProps, RegisteredActionItem, RegisteredFilterItem, type Row, SearchFilter, ToolbarFilterComponentProps as SearchToolbarItemProps, SelectFilter, SelectOption, TableAction, TableActionItem, TableActionMenu, TableActionMenuItem, TableConfigContextValue, TableConfigProvider, TableConfigProviderProps, TableContext, TableControls, TableDataProps, TableEmptyState, TableEmptyStateProps, TableHeaderFooterProps, TableInstanceContextValue, TableInstanceProps, TableInstanceProvider, TableInstanceProviderProps, TableInteractionProps, TableLayoutType, TableLoadingState, TableLoadingStateProps, TablePaginationConfigProps, TablePaginationProps, TableResponsiveProps, TableStateProps, TableStylingProps, TextFilter, Toolbar, ToolbarActionItem, ToolbarConfig, ToolbarCustomItem, ToolbarCustomItemComponent, ToolbarFilterComponentProps, ToolbarFilterGroupItem, ToolbarFilterItem, ToolbarItem, ToolbarItemAlignment, ToolbarItemComponentProps, ToolbarItemType, ToolbarRefineContext, ToolbarRenderer, ToolbarRendererRegistry, ToolbarSeparatorItem, ToolbarSeparatorItemComponent, clear, createFilterOnChangeHandler, createFiltersFromValue, getAction, getFilter, hasAction, hasFilter, listActions, listAll, listFilters, normalizeTableOptions, registerAction, registerCustomToolbarItem, registerFilter, registerRefreshToolbarItem, registerSearchToolbarItem, registerSeparatorToolbarItem, removeAction, removeFilter, useDefaultFilter, useFilterHelpers, useRefineTable, useTableConfig, useTableConfigOptional, useTableInstance };
+//# sourceMappingURL=index.d.ts.map