@lumeweb/portal-framework-ui 0.0.1 → 0.1.0

package/dist/cjs/components/data-table/ToolbarRenderer.d.cts

@@ -0,0 +1,45 @@
+import { ExtendedToolbarItem, ToolbarItemComponentProps } from "./DataTable.types.cjs";
+import React from "react";
+import { BaseRecord } from "@refinedev/core";
+
+//#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.cts.map

package/dist/cjs/components/data-table/contexts/FilterHelpers.cjs

@@ -0,0 +1,75 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_components_data_table_toolbarItems_filters_hooks_useFilterOperators = require('../toolbarItems/filters/hooks/useFilterOperators.cjs');
+let _refinedev_core = require("@refinedev/core");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/components/data-table/contexts/FilterHelpers.tsx
+function FilterHelpersProvider({ children, refineTable, getDefaultFilter, getDefaultOperator, getAvailableOperators: getAvailableOperators$1 }) {
+	const defaultGetDefaultFilter = useDefaultFilter(refineTable);
+	const finalGetDefaultFilter = getDefaultFilter || defaultGetDefaultFilter;
+	const defaultGetDefaultOperator = (0, react.useCallback)((fieldType) => {
+		return require_components_data_table_toolbarItems_filters_hooks_useFilterOperators.getDefaultOperatorForFieldType(fieldType);
+	}, []);
+	const finalGetDefaultOperator = getDefaultOperator || defaultGetDefaultOperator;
+	const defaultGetAvailableOperators = (0, react.useCallback)((fieldType) => {
+		return require_components_data_table_toolbarItems_filters_hooks_useFilterOperators.getAvailableOperators(fieldType);
+	}, []);
+	const finalGetAvailableOperators = getAvailableOperators$1 || defaultGetAvailableOperators;
+	const finalGetDefaultFilterRef = (0, react.useRef)(finalGetDefaultFilter);
+	const finalGetDefaultOperatorRef = (0, react.useRef)(finalGetDefaultOperator);
+	const finalGetAvailableOperatorsRef = (0, react.useRef)(finalGetAvailableOperators);
+	(0, react.useEffect)(() => {
+		finalGetDefaultFilterRef.current = finalGetDefaultFilter;
+		finalGetDefaultOperatorRef.current = finalGetDefaultOperator;
+		finalGetAvailableOperatorsRef.current = finalGetAvailableOperators;
+	}, [
+		finalGetDefaultFilter,
+		finalGetDefaultOperator,
+		finalGetAvailableOperators
+	]);
+	const value = (0, react.useMemo)(() => {
+		return {
+			getDefaultFilter: finalGetDefaultFilterRef.current,
+			getDefaultOperator: finalGetDefaultOperatorRef.current,
+			getAvailableOperators: finalGetAvailableOperatorsRef.current
+		};
+	}, []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FilterHelpersContext.Provider, {
+		value,
+		children
+	});
+}
+var FilterHelpersContext, useDefaultFilter, useFilterHelpers;
+var init_FilterHelpers = require_rolldown_runtime.__esmMin((() => {
+	require_components_data_table_toolbarItems_filters_hooks_useFilterOperators.init_useFilterOperators();
+	FilterHelpersContext = (0, react.createContext)(void 0);
+	useDefaultFilter = (refineTable) => {
+		const filtersRef = (0, react.useRef)(refineTable?.refineCore?.filters);
+		(0, react.useEffect)(() => {
+			filtersRef.current = refineTable?.refineCore?.filters;
+		}, [refineTable?.refineCore?.filters]);
+		return (0, react.useCallback)((columnName, operatorType = "eq") => {
+			return (0, _refinedev_core.getDefaultFilter)(columnName, filtersRef.current, operatorType);
+		}, []);
+	};
+	useFilterHelpers = () => {
+		const context = (0, react.useContext)(FilterHelpersContext);
+		if (context === void 0) throw new Error("useFilterHelpers must be used within a FilterHelpersProvider");
+		return context;
+	};
+}));
+
+//#endregion
+init_FilterHelpers();
+exports.FilterHelpersProvider = FilterHelpersProvider;
+Object.defineProperty(exports, 'init_FilterHelpers', {
+  enumerable: true,
+  get: function () {
+    return init_FilterHelpers;
+  }
+});
+exports.useDefaultFilter = useDefaultFilter;
+exports.useFilterHelpers = useFilterHelpers;
+//# sourceMappingURL=FilterHelpers.cjs.map

package/dist/cjs/components/data-table/contexts/FilterHelpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterHelpers.cjs","names":["getDefaultOperatorForFieldType","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":";;;;;;;;AAkEA,SAAgB,sBAAgD,EAC9D,UACA,aACA,kBACA,oBACA,kDACoC;CAEpC,MAAM,0BAA0B,iBAAiB,YAAY;CAC7D,MAAM,wBAAwB,oBAAoB;CAGlD,MAAM,oDACH,cAA8B;AAC7B,SAAOA,2GAA+B,UAAU;IAElD,EAAE,CACH;CACD,MAAM,0BACJ,sBAAsB;CAExB,MAAM,uDACH,cAAwC;AACvC,SAAOC,kGAA4B,UAAU;IAE/C,EAAE,CACH;CACD,MAAM,6BACJC,2BAAyB;CAG3B,MAAM,6CAAkC,sBAAsB;CAC9D,MAAM,+CAAoC,wBAAwB;CAClE,MAAM,kDAAuC,2BAA2B;AAGxE,4BAAgB;AACd,2BAAyB,UAAU;AACnC,6BAA2B,UAAU;AACrC,gCAA8B,UAAU;IACvC;EAAC;EAAuB;EAAyB;EAA2B,CAAC;CAGhF,MAAM,iCAAsB;AAC1B,SAAO;GACL,kBAAkB,yBAAyB;GAC3C,oBAAoB,2BAA2B;GAC/C,uBAAuB,8BAA8B;GACtD;IACA,EAAE,CAAC;AAEN,QACE,2CAAC,qBAAqB;EAAgB;EACnC;GAC6B;;;;sGA3GsB;CAcpD,gDACJ,OACD;CAWY,oBACX,gBACG;EAEH,MAAM,+BAAoB,aAAa,YAAY,QAAQ;AAG3D,6BAAgB;AACd,cAAW,UAAU,aAAa,YAAY;KAC7C,CAAC,aAAa,YAAY,QAAQ,CAAC;AAGtC,iCACG,YAAoB,eAA8B,SAAS;AAO1D,gDALE,YACA,WAAW,SACX,aACD;KAIH,EAAE,CACH;;CA6DU,yBAAmD;EAC9D,MAAM,gCAAqB,qBAAqB;AAChD,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,+DAA+D;AAEjF,SAAO"}

package/dist/cjs/components/data-table/contexts/FilterHelpers.d.cts

@@ -0,0 +1,30 @@
+import { FilterOperator } from "../toolbarItems/filters/types.cjs";
+import React from "react";
+import { BaseRecord, CrudFilter, CrudOperators } from "@refinedev/core";
+
+//#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.cts.map

package/dist/cjs/components/data-table/contexts/RefineTable.cjs

@@ -0,0 +1,83 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+let fast_deep_equal = require("fast-deep-equal");
+fast_deep_equal = require_rolldown_runtime.__toESM(fast_deep_equal);
+
+//#region src/components/data-table/contexts/RefineTable.tsx
+function RefineTableProvider({ children, refineTable }) {
+	const [version, setVersion] = (0, react.useState)(0);
+	const refineTableRef = (0, react.useRef)(refineTable);
+	const setFiltersRef = (0, react.useRef)(refineTable?.refineCore?.setFilters);
+	const setSortersRef = (0, react.useRef)(refineTable?.refineCore?.setSorters);
+	const tableQueryRef = (0, react.useRef)(refineTable?.refineCore?.tableQuery);
+	const filtersRef = (0, react.useRef)(refineTable?.refineCore?.filters);
+	const sortersRef = (0, react.useRef)(refineTable?.refineCore?.sorters);
+	const prevFiltersRef = (0, react.useRef)(refineTable?.refineCore?.filters);
+	const prevSortersRef = (0, react.useRef)(refineTable?.refineCore?.sorters);
+	(0, react.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 (!(0, fast_deep_equal.default)(prevFiltersRef.current, newFilters)) {
+			filtersRef.current = newFilters;
+			prevFiltersRef.current = newFilters;
+			hasChanges = true;
+		}
+		const newSorters = refineTable?.refineCore?.sorters || [];
+		if (!(0, fast_deep_equal.default)(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 = (0, react.useMemo)(() => {
+		return {
+			refineTable: refineTableRef.current,
+			setFilters: setFiltersRef.current,
+			setSorters: setSortersRef.current,
+			tableQuery: tableQueryRef.current,
+			filters: filtersRef.current,
+			sorters: sortersRef.current
+		};
+	}, [version]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RefineTableContext.Provider, {
+		value,
+		children
+	});
+}
+var RefineTableContext, useRefineTable;
+var init_RefineTable = require_rolldown_runtime.__esmMin((() => {
+	RefineTableContext = (0, react.createContext)(void 0);
+	useRefineTable = () => {
+		const context = (0, react.useContext)(RefineTableContext);
+		if (context === void 0) throw new Error("useRefineTable must be used within a RefineTableProvider");
+		return context;
+	};
+}));
+
+//#endregion
+init_RefineTable();
+exports.RefineTableProvider = RefineTableProvider;
+Object.defineProperty(exports, 'init_RefineTable', {
+  enumerable: true,
+  get: function () {
+    return init_RefineTable;
+  }
+});
+exports.useRefineTable = useRefineTable;
+//# sourceMappingURL=RefineTable.cjs.map

package/dist/cjs/components/data-table/contexts/RefineTable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefineTable.cjs","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,kCAAuB,EAAE;CAGzC,MAAM,mCAAwB,YAAY;CAC1C,MAAM,kCAAuB,aAAa,YAAY,WAAW;CACjE,MAAM,kCAAuB,aAAa,YAAY,WAAW;CACjE,MAAM,kCAAuB,aAAa,YAAY,WAAW;CACjE,MAAM,+BAAoB,aAAa,YAAY,QAAQ;CAC3D,MAAM,+BAAoB,aAAa,YAAY,QAAQ;CAG3D,MAAM,mCAAwB,aAAa,YAAY,QAAQ;CAC/D,MAAM,mCAAwB,aAAa,YAAY,QAAQ;AAG/D,4BAAgB;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,8BAAW,eAAe,SAAS,WAAW,EAEjD;AAClB,cAAW,UAAU;AACrB,kBAAe,UAAU;AACzB,gBAAa;;EAIf,MAAM,aAAa,aAAa,YAAY,WAAW,EAAE;AAGzD,MAFuB,8BAAW,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,iCAAsB;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,2CAAC,mBAAmB;EAAgB;EACjC;GAC2B;;;;CA5F5B,8CAEJ,OAAU;CA8FC,uBAAiD;EAC5D,MAAM,gCAAqB,mBAAmB;AAE9C,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAG7E,SAAO"}

package/dist/cjs/components/data-table/contexts/RefineTable.d.cts

@@ -0,0 +1,25 @@
+import React from "react";
+import { BaseRecord } from "@refinedev/core";
+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.cts.map

package/dist/cjs/components/data-table/contexts/TableConfig.cjs

@@ -0,0 +1,43 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/components/data-table/contexts/TableConfig.tsx
+function TableConfigProvider({ children, toolbarConfig, refineContext }) {
+	const value = (0, react.useMemo)(() => {
+		return {
+			toolbarConfig,
+			refineContext
+		};
+	}, [toolbarConfig, refineContext]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TableConfigContext.Provider, {
+		value,
+		children
+	});
+}
+var TableConfigContext, useTableConfig, useTableConfigOptional;
+var init_TableConfig = require_rolldown_runtime.__esmMin((() => {
+	TableConfigContext = (0, react.createContext)(void 0);
+	useTableConfig = () => {
+		const context = (0, react.useContext)(TableConfigContext);
+		if (context === void 0) throw new Error("useTableConfig must be used within a TableConfigProvider");
+		return context;
+	};
+	useTableConfigOptional = () => {
+		return (0, react.useContext)(TableConfigContext);
+	};
+}));
+
+//#endregion
+init_TableConfig();
+exports.TableConfigProvider = TableConfigProvider;
+Object.defineProperty(exports, 'init_TableConfig', {
+  enumerable: true,
+  get: function () {
+    return init_TableConfig;
+  }
+});
+exports.useTableConfig = useTableConfig;
+exports.useTableConfigOptional = useTableConfigOptional;
+//# sourceMappingURL=TableConfig.cjs.map

package/dist/cjs/components/data-table/contexts/TableConfig.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableConfig.cjs","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,iCAAsB;AAC1B,SAAO;GACL;GACA;GACD;IACA,CAAC,eAAe,cAAc,CAAC;AAElC,QACE,2CAAC,mBAAmB;EAAgB;EACjC;GAC2B;;;;CAzB5B,8CACJ,OACD;CA2BY,uBAAiD;EAC5D,MAAM,gCAAqB,mBAAmB;AAC9C,MAAI,YAAY,OACd,OAAM,IAAI,MAAM,2DAA2D;AAE7E,SAAO;;CAGI,+BAAyD;AAEpE,+BAD2B,mBAAmB"}

package/dist/cjs/components/data-table/contexts/TableConfig.d.cts

@@ -0,0 +1,24 @@
+import { ToolbarConfig, ToolbarRefineContext } from "../DataTable.types.cjs";
+import React from "react";
+import { BaseRecord } from "@refinedev/core";
+
+//#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.cts.map

package/dist/cjs/components/data-table/contexts/TableInstance.cjs

@@ -0,0 +1,34 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/components/data-table/contexts/TableInstance.tsx
+function TableInstanceProvider({ children, table }) {
+	const value = { table };
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TableInstanceContext.Provider, {
+		value,
+		children
+	});
+}
+var TableInstanceContext, useTableInstance;
+var init_TableInstance = require_rolldown_runtime.__esmMin((() => {
+	TableInstanceContext = (0, react.createContext)(void 0);
+	useTableInstance = () => {
+		const context = (0, react.useContext)(TableInstanceContext);
+		if (context === void 0) throw new Error("useTableInstance must be used within a TableInstanceProvider");
+		return context;
+	};
+}));
+
+//#endregion
+init_TableInstance();
+exports.TableInstanceProvider = TableInstanceProvider;
+Object.defineProperty(exports, 'init_TableInstance', {
+  enumerable: true,
+  get: function () {
+    return init_TableInstance;
+  }
+});
+exports.useTableInstance = useTableInstance;
+//# sourceMappingURL=TableInstance.cjs.map

package/dist/cjs/components/data-table/contexts/TableInstance.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableInstance.cjs","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,2CAAC,qBAAqB;EAAgB;EACnC;GAC6B;;;;CApB9B,gDAEJ,OAAU;CAsBC,yBAAmD;EAC9D,MAAM,gCAAqB,qBAAqB;AAChD,MAAI,YAAY,OACd,OAAM,IAAI,MACR,+DACD;AAEH,SAAO"}

package/dist/cjs/components/data-table/contexts/TableInstance.d.cts

@@ -0,0 +1,20 @@
+import React from "react";
+import { BaseRecord } from "@refinedev/core";
+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.cts.map

package/dist/cjs/components/data-table/contexts/index.cjs

@@ -0,0 +1,33 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_components_data_table_contexts_FilterHelpers = require('./FilterHelpers.cjs');
+const require_components_data_table_contexts_RefineTable = require('./RefineTable.cjs');
+const require_components_data_table_contexts_TableConfig = require('./TableConfig.cjs');
+const require_components_data_table_contexts_TableInstance = require('./TableInstance.cjs');
+
+//#region src/components/data-table/contexts/index.ts
+var init_contexts = require_rolldown_runtime.__esmMin((() => {
+	init_FilterHelpers();
+	init_RefineTable();
+	init_TableConfig();
+	init_TableInstance();
+}));
+
+//#endregion
+init_contexts();
+exports.FilterHelpersProvider = require_components_data_table_contexts_FilterHelpers.FilterHelpersProvider;
+exports.RefineTableProvider = require_components_data_table_contexts_RefineTable.RefineTableProvider;
+exports.TableConfigProvider = require_components_data_table_contexts_TableConfig.TableConfigProvider;
+exports.TableInstanceProvider = require_components_data_table_contexts_TableInstance.TableInstanceProvider;
+Object.defineProperty(exports, 'init_contexts', {
+  enumerable: true,
+  get: function () {
+    return init_contexts;
+  }
+});
+exports.useDefaultFilter = require_components_data_table_contexts_FilterHelpers.useDefaultFilter;
+exports.useFilterHelpers = require_components_data_table_contexts_FilterHelpers.useFilterHelpers;
+exports.useRefineTable = require_components_data_table_contexts_RefineTable.useRefineTable;
+exports.useTableConfig = require_components_data_table_contexts_TableConfig.useTableConfig;
+exports.useTableConfigOptional = require_components_data_table_contexts_TableConfig.useTableConfigOptional;
+exports.useTableInstance = require_components_data_table_contexts_TableInstance.useTableInstance;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/components/data-table/contexts/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../../src/components/data-table/contexts/index.ts"],"sourcesContent":["export * from \"./FilterHelpers\";\nexport * from \"./RefineTable\";\nexport * from \"./TableConfig\";\nexport * from \"./TableInstance\";\n"],"mappings":""}

package/dist/cjs/components/data-table/contexts/index.d.cts

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

package/dist/cjs/components/data-table/filterColumnsForMobile.cjs

@@ -0,0 +1,41 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+
+//#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;
+	});
+}
+var init_filterColumnsForMobile = require_rolldown_runtime.__esmMin((() => {}));
+
+//#endregion
+init_filterColumnsForMobile();
+exports.filterColumnsForMobile = filterColumnsForMobile;
+Object.defineProperty(exports, 'init_filterColumnsForMobile', {
+  enumerable: true,
+  get: function () {
+    return init_filterColumnsForMobile;
+  }
+});
+//# sourceMappingURL=filterColumnsForMobile.cjs.map

package/dist/cjs/components/data-table/filterColumnsForMobile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterColumnsForMobile.cjs","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/cjs/components/data-table/filterColumnsForMobile.d.cts

@@ -0,0 +1,17 @@
+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.cts.map