@lumeweb/portal-framework-ui 0.0.1 → 0.1.0

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

@@ -0,0 +1,95 @@
+import { __esmMin } from "../../_virtual/rolldown_runtime.js";
+
+//#region src/components/data-table/ToolbarRegistry.tsx
+/**
+* Register a toolbar action item
+*/
+function registerAction(id, item) {
+	actions.set(id, item);
+}
+/**
+* Register a toolbar filter item
+*/
+function registerFilter(id, item) {
+	filters.set(id, item);
+}
+/**
+* Get a registered action item by ID
+*/
+function getAction(id) {
+	return actions.get(id);
+}
+/**
+* Get a registered filter item by ID
+*/
+function getFilter(id) {
+	return filters.get(id);
+}
+/**
+* Check if an action item exists
+*/
+function hasAction(id) {
+	return actions.has(id);
+}
+/**
+* Check if a filter item exists
+*/
+function hasFilter(id) {
+	return filters.has(id);
+}
+/**
+* Get all registered action items
+*/
+function listActions() {
+	return Array.from(actions.entries()).map(([id, item]) => ({
+		id,
+		item
+	}));
+}
+/**
+* Get all registered filter items
+*/
+function listFilters() {
+	return Array.from(filters.entries()).map(([id, item]) => ({
+		id,
+		item
+	}));
+}
+/**
+* Get all registered items
+*/
+function listAll() {
+	return {
+		actions: listActions(),
+		filters: listFilters()
+	};
+}
+/**
+* Clear all registered items
+*/
+function clear() {
+	actions.clear();
+	filters.clear();
+}
+/**
+* Remove a specific action item
+*/
+function removeAction(id) {
+	return actions.delete(id);
+}
+/**
+* Remove a specific filter item
+*/
+function removeFilter(id) {
+	return filters.delete(id);
+}
+var actions, filters;
+var init_ToolbarRegistry = __esmMin(() => {
+	actions = /* @__PURE__ */ new Map();
+	filters = /* @__PURE__ */ new Map();
+});
+
+//#endregion
+init_ToolbarRegistry();
+export { clear, getAction, getFilter, hasAction, hasFilter, init_ToolbarRegistry, listActions, listAll, listFilters, registerAction, registerFilter, removeAction, removeFilter };
+//# sourceMappingURL=ToolbarRegistry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToolbarRegistry.js","names":[],"sources":["../../../../src/components/data-table/ToolbarRegistry.tsx"],"sourcesContent":["import type {\n  ToolbarActionItem,\n  ToolbarFilterItem,\n} from \"./\";\nimport { BaseRecord } from \"@refinedev/core\";\n\ninterface RegisteredActionItem<TData extends BaseRecord> {\n  id: string;\n  item: ToolbarActionItem<TData>;\n}\n\ninterface RegisteredFilterItem<TData extends BaseRecord> {\n  id: string;\n  item: ToolbarFilterItem<TData>;\n}\n\n// Module-level private state\nconst actions: Map<string, ToolbarActionItem<any>> = new Map();\nconst filters: Map<string, ToolbarFilterItem<any>> = new Map();\n\n/**\n * Register a toolbar action item\n */\nfunction registerAction<TData extends BaseRecord>(\n  id: string,\n  item: ToolbarActionItem<TData>,\n): void {\n  actions.set(id, item);\n}\n\n/**\n * Register a toolbar filter item\n */\nfunction registerFilter<TData extends BaseRecord>(\n  id: string,\n  item: ToolbarFilterItem<TData>,\n): void {\n  filters.set(id, item as ToolbarFilterItem<any>);\n}\n\n/**\n * Get a registered action item by ID\n */\nfunction getAction<TData extends BaseRecord>(\n  id: string,\n): ToolbarActionItem<TData> | undefined {\n  return actions.get(id);\n}\n\n/**\n * Get a registered filter item by ID\n */\nfunction getFilter<TData extends BaseRecord>(\n  id: string,\n): ToolbarFilterItem<TData> | undefined {\n  return filters.get(id) as ToolbarFilterItem<TData> | undefined;\n}\n\n/**\n * Check if an action item exists\n */\nfunction hasAction(id: string): boolean {\n  return actions.has(id);\n}\n\n/**\n * Check if a filter item exists\n */\nfunction hasFilter(id: string): boolean {\n  return filters.has(id);\n}\n\n/**\n * Get all registered action items\n */\nfunction listActions<\n  TData extends BaseRecord,\n>(): RegisteredActionItem<TData>[] {\n  return Array.from(actions.entries()).map(([id, item]) => ({\n    id,\n    item: item as ToolbarActionItem<TData>,\n  }));\n}\n\n/**\n * Get all registered filter items\n */\nfunction listFilters<\n  TData extends BaseRecord,\n>(): RegisteredFilterItem<TData>[] {\n  return Array.from(filters.entries()).map(([id, item]) => ({\n    id,\n    item: item as ToolbarFilterItem<TData>,\n  }));\n}\n\n/**\n * Get all registered items\n */\nfunction listAll<TData extends BaseRecord>() {\n  return {\n    actions: listActions<TData>(),\n    filters: listFilters<TData>(),\n  };\n}\n\n/**\n * Clear all registered items\n */\nfunction clear(): void {\n  actions.clear();\n  filters.clear();\n}\n\n/**\n * Remove a specific action item\n */\nfunction removeAction(id: string): boolean {\n  return actions.delete(id);\n}\n\n/**\n * Remove a specific filter item\n */\nfunction removeFilter(id: string): boolean {\n  return filters.delete(id);\n}\n\nexport {\n  registerAction,\n  getAction,\n  registerFilter,\n  getFilter,\n  hasAction,\n  hasFilter,\n  listActions,\n  listFilters,\n  listAll,\n  clear,\n  removeAction,\n  removeFilter,\n};\n\nexport type {\n  RegisteredActionItem,\n  RegisteredFilterItem,\n};\n"],"mappings":";;;;;;AAuBA,SAAS,eACP,IACA,MACM;AACN,SAAQ,IAAI,IAAI,KAAK;;;;;AAMvB,SAAS,eACP,IACA,MACM;AACN,SAAQ,IAAI,IAAI,KAA+B;;;;;AAMjD,SAAS,UACP,IACsC;AACtC,QAAO,QAAQ,IAAI,GAAG;;;;;AAMxB,SAAS,UACP,IACsC;AACtC,QAAO,QAAQ,IAAI,GAAG;;;;;AAMxB,SAAS,UAAU,IAAqB;AACtC,QAAO,QAAQ,IAAI,GAAG;;;;;AAMxB,SAAS,UAAU,IAAqB;AACtC,QAAO,QAAQ,IAAI,GAAG;;;;;AAMxB,SAAS,cAE0B;AACjC,QAAO,MAAM,KAAK,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW;EACxD;EACM;EACP,EAAE;;;;;AAML,SAAS,cAE0B;AACjC,QAAO,MAAM,KAAK,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW;EACxD;EACM;EACP,EAAE;;;;;AAML,SAAS,UAAoC;AAC3C,QAAO;EACL,SAAS,aAAoB;EAC7B,SAAS,aAAoB;EAC9B;;;;;AAMH,SAAS,QAAc;AACrB,SAAQ,OAAO;AACf,SAAQ,OAAO;;;;;AAMjB,SAAS,aAAa,IAAqB;AACzC,QAAO,QAAQ,OAAO,GAAG;;;;;AAM3B,SAAS,aAAa,IAAqB;AACzC,QAAO,QAAQ,OAAO,GAAG;;;;CA5GrB,0BAA+C,IAAI,KAAK;CACxD,0BAA+C,IAAI,KAAK"}

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

@@ -0,0 +1,45 @@
+import { ExtendedToolbarItem, ToolbarItemComponentProps } from "./DataTable.types.js";
+import { BaseRecord } from "@refinedev/core";
+import React from "react";
+
+//#region src/components/data-table/ToolbarRenderer.d.ts
+type ToolbarItemRenderer<TData extends BaseRecord> = (item: ExtendedToolbarItem<TData>, commonProps: ToolbarItemComponentProps<TData>) => React.ReactNode;
+declare const ToolbarRendererRegistry: {
+  /**
+   * Register a custom renderer for a toolbar item type
+   */
+  register<TData extends BaseRecord>(type: string, renderer: ToolbarItemRenderer<TData>): void;
+  /**
+   * Get a registered renderer for a toolbar item type
+   */
+  get<TData extends BaseRecord>(type: string): ToolbarItemRenderer<TData> | undefined;
+  /**
+   * Check if a renderer is registered for a type
+   */
+  has(type: string): boolean;
+  /**
+   * Remove a registered renderer
+   */
+  remove(type: string): boolean;
+  /**
+   * Clear all registered renderers
+   */
+  clear(): void;
+  list(): string[];
+};
+interface ToolbarRendererProps<TData extends BaseRecord> {
+  /** The toolbar item to render */
+  item: ExtendedToolbarItem<TData>;
+  /** Common props passed to all toolbar item components */
+  commonProps: ToolbarItemComponentProps<TData>;
+  /** Additional class name for the item container */
+  className?: string;
+}
+declare function ToolbarRenderer<TData extends BaseRecord>({
+  item,
+  commonProps,
+  className
+}: ToolbarRendererProps<TData>): any;
+//#endregion
+export { ToolbarRenderer, ToolbarRendererRegistry };
+//# sourceMappingURL=ToolbarRenderer.d.ts.map

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

@@ -0,0 +1,133 @@
+import { __esmMin } from "../../_virtual/rolldown_runtime.js";
+import { ToolbarItemType, init_DataTable_types } from "./DataTable.types.js";
+import { getAction, init_ToolbarRegistry } from "./ToolbarRegistry.js";
+import { FilterResolver, init_FilterResolver } from "./toolbarItems/FilterResolver.js";
+import { ComponentSize as ComponentSize$1 } from "../sizing/index.js";
+import { FilterGroup, init_FilterGroup } from "./toolbarItems/FilterGroup.js";
+import { init_useMobileDetection, useMobileDetection as useMobileDetection$1 } from "./useMobileDetection.js";
+import { init_components } from "../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
+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(ToolbarItemType.ACTION, ActionItemRenderer);
+	toolbarItemRenderers.set(ToolbarItemType.FILTER, FilterItemRenderer);
+	toolbarItemRenderers.set(ToolbarItemType.FILTER_GROUP, FilterGroupItemRenderer);
+	toolbarItemRenderers.set(ToolbarItemType.SEPARATOR, SeparatorItemRenderer);
+}
+function ToolbarRenderer({ item, commonProps, className }) {
+	const mobileBreakpoint = commonProps.context?.toolbarConfig?.mobileBreakpoint;
+	const candidate = mobileBreakpoint && Object.values(ComponentSize$1).includes(mobileBreakpoint) ? mobileBreakpoint : ComponentSize$1.SM;
+	const { isMobile } = useMobileDetection$1({ mobileBreakpoint: (typeof candidate === "string" && !coreSupported.has(candidate) ? ComponentSize$1.SM : candidate) || ComponentSize$1.SM });
+	const containerClassName = cn("flex items-center", item.type === ToolbarItemType.SEPARATOR && "mx-2", className);
+	if (item.type === ToolbarItemType.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)
+	});
+}
+var toolbarItemRenderers, coreSupported, ToolbarRendererRegistry;
+var init_ToolbarRenderer = __esmMin(() => {
+	init_FilterGroup();
+	init_FilterResolver();
+	init_DataTable_types();
+	init_ToolbarRegistry();
+	init_useMobileDetection();
+	init_components();
+	toolbarItemRenderers = /* @__PURE__ */ new Map();
+	coreSupported = new Set([
+		"xs",
+		"sm",
+		"md",
+		"lg",
+		"xl",
+		"2xl",
+		"3xl",
+		"4xl",
+		"5xl",
+		"6xl",
+		"7xl",
+		"auto",
+		"full"
+	]);
+	registerDefaultRenderers();
+	ToolbarRendererRegistry = {
+		register(type, renderer) {
+			toolbarItemRenderers.set(type, renderer);
+		},
+		get(type) {
+			return toolbarItemRenderers.get(type);
+		},
+		has(type) {
+			return toolbarItemRenderers.has(type);
+		},
+		remove(type) {
+			return toolbarItemRenderers.delete(type);
+		},
+		clear() {
+			toolbarItemRenderers.clear();
+			registerDefaultRenderers();
+		},
+		list() {
+			return Array.from(toolbarItemRenderers.keys());
+		}
+	};
+});
+
+//#endregion
+init_ToolbarRenderer();
+export { ToolbarRenderer, ToolbarRendererRegistry, init_ToolbarRenderer };
+//# sourceMappingURL=ToolbarRenderer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToolbarRenderer.js","names":["ComponentSize","useMobileDetection"],"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":";;;;;;;;;;;;;AA+BA,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;EACC,WAAW,WAAW;EACtB,UAAU,WAAW;EACrB,eAAe,WAAW,QAAQ,YAAY;EAC9C,MAAM;EACN,OAAO,WAAW;EAClB,SAAS,WAAW;aACnB,WAAW,QAAQ,oBAAC;GAAK,WAAU;aAAQ,WAAW;IAAY,EAClE,WAAW;GACL;;AAIb,SAAS,mBACP,MACA,aACA;CACA,MAAM,aAAa;AAEnB,QACE,qBAAC;EAAI,WAAU;aACb,oBAAC;GAAM,WAAU;aAAuB,WAAW;IAAc,EACjE,oBAAC;GAA2B;GAAyB;IAAe;GAChE;;AAIV,SAAS,wBACP,MACA,aACA;AAGA,QAAO,oBAAC;EAFgB;EAEgC;GAAe;;AAGzE,SAAS,sBACP,MACA,aACA;AACA,QAAO,oBAAC,SAAI,WAAU,yBAAyB;;AAIjD,SAAS,2BAA2B;AAElC,sBAAqB,IAAI,gBAAgB,QAAQ,mBAAmB;AACpE,sBAAqB,IAAI,gBAAgB,QAAQ,mBAAmB;AACpE,sBAAqB,IACnB,gBAAgB,cAChB,wBACD;AAGD,sBAAqB,IAAI,gBAAgB,WAAW,sBAAsB;;AA+D5E,SAAS,gBAA0C,EACjD,MACA,aACA,aAC8B;CAE9B,MAAM,mBAAmB,YAAY,SAAS,eAAe;CAC7D,MAAM,YACJ,oBACA,OAAO,OAAOA,gBAAc,CAAC,SAAS,iBAAkC,GACpE,mBACAA,gBAAc;CAQpB,MAAM,EAAE,aAAaC,qBAAmB,EACtC,mBANA,OAAO,cAAc,YAAY,CAAC,cAAc,IAAI,UAAU,GAC1DD,gBAAc,KACd,cAIgCA,gBAAc,IACnD,CAAC;CAEF,MAAM,qBAAqB,GACzB,qBACA,KAAK,SAAS,gBAAgB,aAAa,QAC3C,UACD;AAGD,KAAI,KAAK,SAAS,gBAAgB,QAAQ;EAExC,MAAM,kBADa,KACgB;AAEnC,MAAI,gBACF,QACE,oBAAC;GAAI,WAAW;aACd,oBAAC,mBAAgB,GAAI,cAAe;IAChC;AAIV,SAAO;;CAGT,MAAM,WAAW,wBAAwB,IAAW,KAAK,KAAK;AAE9D,KAAI,CAAC,UAAU;AACb,UAAQ,KAAK,iDAAiD,KAAK,OAAO;AAC1E,SAAO;;AAKT,QAAO,oBAAC;EAAI,WAAW;YAFF,SAAS,MAAM,aAAa,SAAS;GAEK;;;;mBApNR;sBACM;uBAUpC;uBAEmB;0BACY;kBACb;CAQvC,uCAAuB,IAAI,KAAuC;CAGlE,gBAAgB,IAAI,IAAI;EAAC;EAAM;EAAM;EAAM;EAAM;EAAM;EAAO;EAAO;EAAO;EAAO;EAAO;EAAO;EAAQ;EAAO,CAAC;AAyEvH,2BAA0B;CAGb,0BAA0B;EAIrC,SACE,MACA,UACA;AACA,wBAAqB,IAAI,MAAM,SAAS;;EAM1C,IACE,MACwC;AACxC,UAAO,qBAAqB,IAAI,KAAK;;EAMvC,IAAI,MAAuB;AACzB,UAAO,qBAAqB,IAAI,KAAK;;EAMvC,OAAO,MAAuB;AAC5B,UAAO,qBAAqB,OAAO,KAAK;;EAM1C,QAAQ;AACN,wBAAqB,OAAO;AAC5B,6BAA0B;;EAG5B,OAAiB;AACf,UAAO,MAAM,KAAK,qBAAqB,MAAM,CAAC;;EAEjD"}

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,66 @@
+import { __esmMin } from "../../../_virtual/rolldown_runtime.js";
+import { getAvailableOperators, getDefaultOperatorForFieldType, init_useFilterOperators } 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
+function FilterHelpersProvider({ children, refineTable, getDefaultFilter: getDefaultFilter$1, getDefaultOperator, getAvailableOperators: getAvailableOperators$1 }) {
+	const defaultGetDefaultFilter = useDefaultFilter(refineTable);
+	const finalGetDefaultFilter = getDefaultFilter$1 || 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
+	});
+}
+var FilterHelpersContext, useDefaultFilter, useFilterHelpers;
+var init_FilterHelpers = __esmMin(() => {
+	init_useFilterOperators();
+	FilterHelpersContext = createContext(void 0);
+	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);
+		}, []);
+	};
+	useFilterHelpers = () => {
+		const context = useContext(FilterHelpersContext);
+		if (context === void 0) throw new Error("useFilterHelpers must be used within a FilterHelpersProvider");
+		return context;
+	};
+});
+
+//#endregion
+init_FilterHelpers();
+export { FilterHelpersProvider, init_FilterHelpers, 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":["getDefaultFilter","getAvailableOperatorsHelper","getAvailableOperators","refineGetDefaultFilter"],"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":";;;;;;;AAkEA,SAAgB,sBAAgD,EAC9D,UACA,aACA,sCACA,oBACA,kDACoC;CAEpC,MAAM,0BAA0B,iBAAiB,YAAY;CAC7D,MAAM,wBAAwBA,sBAAoB;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;EAAgB;EACnC;GAC6B;;;;0BA3GsB;CAcpD,uBAAuB,cAC3B,OACD;CAWY,oBACX,gBACG;EAEH,MAAM,aAAa,OAAO,aAAa,YAAY,QAAQ;AAG3D,kBAAgB;AACd,cAAW,UAAU,aAAa,YAAY;KAC7C,CAAC,aAAa,YAAY,QAAQ,CAAC;AAGtC,SAAO,aACJ,YAAoB,eAA8B,SAAS;AAO1D,UANeC,iBACb,YACA,WAAW,SACX,aACD;KAIH,EAAE,CACH;;CA6DU,yBAAmD;EAC9D,MAAM,UAAU,WAAW,qBAAqB;AAChD,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,+DAA+D;AAEjF,SAAO"}

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,74 @@
+import { __esmMin } from "../../../_virtual/rolldown_runtime.js";
+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
+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
+	});
+}
+var RefineTableContext, useRefineTable;
+var init_RefineTable = __esmMin(() => {
+	RefineTableContext = createContext(void 0);
+	useRefineTable = () => {
+		const context = useContext(RefineTableContext);
+		if (context === void 0) throw new Error("useRefineTable must be used within a RefineTableProvider");
+		return context;
+	};
+});
+
+//#endregion
+init_RefineTable();
+export { RefineTableProvider, init_RefineTable, 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":";;;;;;AA8BA,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,MAFuB,CAAC,UAAU,eAAe,SAAS,WAAW,EAEjD;AAClB,cAAW,UAAU;AACrB,kBAAe,UAAU;AACzB,gBAAa;;EAIf,MAAM,aAAa,aAAa,YAAY,WAAW,EAAE;AAGzD,MAFuB,CAAC,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;EAAgB;EACjC;GAC2B;;;;CA5F5B,qBAAqB,cAEzB,OAAU;CA8FC,uBAAiD;EAC5D,MAAM,UAAU,WAAW,mBAAmB;AAE9C,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAG7E,SAAO"}

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,34 @@
+import { __esmMin } from "../../../_virtual/rolldown_runtime.js";
+import React, { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/data-table/contexts/TableConfig.tsx
+function TableConfigProvider({ children, toolbarConfig, refineContext }) {
+	const value = useMemo(() => {
+		return {
+			toolbarConfig,
+			refineContext
+		};
+	}, [toolbarConfig, refineContext]);
+	return /* @__PURE__ */ jsx(TableConfigContext.Provider, {
+		value,
+		children
+	});
+}
+var TableConfigContext, useTableConfig, useTableConfigOptional;
+var init_TableConfig = __esmMin(() => {
+	TableConfigContext = createContext(void 0);
+	useTableConfig = () => {
+		const context = useContext(TableConfigContext);
+		if (context === void 0) throw new Error("useTableConfig must be used within a TableConfigProvider");
+		return context;
+	};
+	useTableConfigOptional = () => {
+		return useContext(TableConfigContext);
+	};
+});
+
+//#endregion
+init_TableConfig();
+export { TableConfigProvider, init_TableConfig, 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":";;;;;AAuBA,SAAgB,oBAA8C,EAC5D,UACA,eACA,iBACkC;CAClC,MAAM,QAAQ,cAAc;AAC1B,SAAO;GACL;GACA;GACD;IACA,CAAC,eAAe,cAAc,CAAC;AAElC,QACE,oBAAC,mBAAmB;EAAgB;EACjC;GAC2B;;;;CAzB5B,qBAAqB,cACzB,OACD;CA2BY,uBAAiD;EAC5D,MAAM,UAAU,WAAW,mBAAmB;AAC9C,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAE7E,SAAO;;CAGI,+BAAyD;AAEpE,SADgB,WAAW,mBAAmB"}

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,26 @@
+import { __esmMin } from "../../../_virtual/rolldown_runtime.js";
+import React, { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/data-table/contexts/TableInstance.tsx
+function TableInstanceProvider({ children, table }) {
+	const value = { table };
+	return /* @__PURE__ */ jsx(TableInstanceContext.Provider, {
+		value,
+		children
+	});
+}
+var TableInstanceContext, useTableInstance;
+var init_TableInstance = __esmMin(() => {
+	TableInstanceContext = createContext(void 0);
+	useTableInstance = () => {
+		const context = useContext(TableInstanceContext);
+		if (context === void 0) throw new Error("useTableInstance must be used within a TableInstanceProvider");
+		return context;
+	};
+});
+
+//#endregion
+init_TableInstance();
+export { TableInstanceProvider, init_TableInstance, 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":";;;;;AAoBA,SAAgB,sBAAgD,EAC9D,UACA,SACoC;CACpC,MAAM,QAAQ,EACZ,OACD;AAED,QACE,oBAAC,qBAAqB;EAAgB;EACnC;GAC6B;;;;CApB9B,uBAAuB,cAE3B,OAAU;CAsBC,yBAAmD;EAC9D,MAAM,UAAU,WAAW,qBAAqB;AAChD,MAAI,YAAY,OACd,OAAM,IAAI,MACR,+DACD;AAEH,SAAO"}