@refinedev/core 4.47.2 → 4.49.0

package/src/definitions/table/index.ts

@@ -1,192 +1,188 @@
-import qs, { IStringifyOptions } from "qs";
-import unionWith from "lodash/unionWith";
 import differenceWith from "lodash/differenceWith";
+import unionWith from "lodash/unionWith";
+import qs, { IStringifyOptions } from "qs";
 import warnOnce from "warn-once";
 
-import {
-    CrudFilters,
-    CrudSorting,
-    CrudFilter,
-    CrudSort,
-    CrudOperators,
-    SortOrder,
-} from "../../interfaces";
 import { pickNotDeprecated } from "@definitions/helpers";
 
-export const parseTableParams = (url: string) => {
-    const { current, pageSize, sorter, sorters, filters } = qs.parse(
-        url.substring(1), // remove first ? character
-    );
+import {
+  CrudFilter,
+  CrudOperators,
+  CrudSort,
+  SortOrder,
+} from "../../contexts/data/types";
 
-    return {
-        parsedCurrent: current && Number(current),
-        parsedPageSize: pageSize && Number(pageSize),
-        parsedSorter: (pickNotDeprecated(sorters, sorter) as CrudSorting) ?? [],
-        parsedFilters: (filters as CrudFilters) ?? [],
-    };
+export const parseTableParams = (url: string) => {
+  const { current, pageSize, sorter, sorters, filters } = qs.parse(
+    url.substring(1), // remove first ? character
+  );
+
+  return {
+    parsedCurrent: current && Number(current),
+    parsedPageSize: pageSize && Number(pageSize),
+    parsedSorter: (pickNotDeprecated(sorters, sorter) as CrudSort[]) ?? [],
+    parsedFilters: (filters as CrudFilter[]) ?? [],
+  };
 };
 
 export const parseTableParamsFromQuery = (params: any) => {
-    const url = qs.stringify(params);
-    return parseTableParams(`/${url}`);
+  const url = qs.stringify(params);
+  return parseTableParams(`/${url}`);
 };
 
 /**
  * @internal This function is used to stringify table params from the useTable hook.
  */
 export const stringifyTableParams = (params: {
-    pagination?: { current?: number; pageSize?: number };
-    sorters: CrudSorting;
-    filters: CrudFilters;
-    [key: string]: any;
+  pagination?: { current?: number; pageSize?: number };
+  sorters: CrudSort[];
+  filters: CrudFilter[];
+  [key: string]: any;
 }): string => {
-    const options: IStringifyOptions = {
-        skipNulls: true,
-        arrayFormat: "indices",
-        encode: false,
-    };
-    const { pagination, sorter, sorters, filters, ...rest } = params;
-
-    const queryString = qs.stringify(
-        {
-            ...rest,
-            ...(pagination ? pagination : {}),
-            sorters: pickNotDeprecated(sorters, sorter),
-            filters,
-        },
-        options,
-    );
-
-    return queryString;
+  const options: IStringifyOptions = {
+    skipNulls: true,
+    arrayFormat: "indices",
+    encode: false,
+  };
+  const { pagination, sorter, sorters, filters, ...rest } = params;
+
+  const queryString = qs.stringify(
+    {
+      ...rest,
+      ...(pagination ? pagination : {}),
+      sorters: pickNotDeprecated(sorters, sorter),
+      filters,
+    },
+    options,
+  );
+
+  return queryString;
 };
 
 export const compareFilters = (
-    left: CrudFilter,
-    right: CrudFilter,
+  left: CrudFilter,
+  right: CrudFilter,
 ): boolean => {
-    if (
-        left.operator !== "and" &&
-        left.operator !== "or" &&
-        right.operator !== "and" &&
-        right.operator !== "or"
-    ) {
-        return (
-            ("field" in left ? left.field : undefined) ==
-                ("field" in right ? right.field : undefined) &&
-            left.operator == right.operator
-        );
-    }
-
+  if (
+    left.operator !== "and" &&
+    left.operator !== "or" &&
+    right.operator !== "and" &&
+    right.operator !== "or"
+  ) {
     return (
-        ("key" in left ? left.key : undefined) ==
-            ("key" in right ? right.key : undefined) &&
-        left.operator == right.operator
+      ("field" in left ? left.field : undefined) ===
+        ("field" in right ? right.field : undefined) &&
+      left.operator === right.operator
     );
+  }
+
+  return (
+    ("key" in left ? left.key : undefined) ===
+      ("key" in right ? right.key : undefined) &&
+    left.operator === right.operator
+  );
 };
 
 export const compareSorters = (left: CrudSort, right: CrudSort): boolean =>
-    left.field == right.field;
+  left.field === right.field;
 // Keep only one CrudFilter per type according to compareFilters
 // Items in the array that is passed first to unionWith have higher priority
 // CrudFilter items with undefined values are necessary to signify no filter
 // After union, don't keep CrudFilter items with undefined value in the result
 // Items in the arrays with higher priority are put at the end.
 export const unionFilters = (
-    permanentFilter: CrudFilters,
-    newFilters: CrudFilters,
-    prevFilters: CrudFilters = [],
-): CrudFilters => {
-    const isKeyRequired = newFilters.filter(
-        (f) => (f.operator === "or" || f.operator === "and") && !f.key,
-    );
-
-    if (isKeyRequired.length > 1) {
-        warnOnce(
-            true,
-            `[conditionalFilters]: You have created multiple Conditional Filters at the top level, this requires the key parameter. \nFor more information, see https://refine.dev/docs/advanced-tutorials/data-provider/handling-filters/#top-level-multiple-conditional-filters-usage`,
-        );
-    }
-
-    return unionWith(
-        permanentFilter,
-        newFilters,
-        prevFilters,
-        compareFilters,
-    ).filter(
-        (crudFilter) =>
-            crudFilter.value !== undefined &&
-            crudFilter.value !== null &&
-            (crudFilter.operator !== "or" ||
-                (crudFilter.operator === "or" &&
-                    crudFilter.value.length !== 0)) &&
-            (crudFilter.operator !== "and" ||
-                (crudFilter.operator === "and" &&
-                    crudFilter.value.length !== 0)),
+  permanentFilter: CrudFilter[],
+  newFilters: CrudFilter[],
+  prevFilters: CrudFilter[] = [],
+): CrudFilter[] => {
+  const isKeyRequired = newFilters.filter(
+    (f) => (f.operator === "or" || f.operator === "and") && !f.key,
+  );
+
+  if (isKeyRequired.length > 1) {
+    warnOnce(
+      true,
+      "[conditionalFilters]: You have created multiple Conditional Filters at the top level, this requires the key parameter. \nFor more information, see https://refine.dev/docs/advanced-tutorials/data-provider/handling-filters/#top-level-multiple-conditional-filters-usage",
     );
+  }
+
+  return unionWith(
+    permanentFilter,
+    newFilters,
+    prevFilters,
+    compareFilters,
+  ).filter(
+    (crudFilter) =>
+      crudFilter.value !== undefined &&
+      crudFilter.value !== null &&
+      (crudFilter.operator !== "or" ||
+        (crudFilter.operator === "or" && crudFilter.value.length !== 0)) &&
+      (crudFilter.operator !== "and" ||
+        (crudFilter.operator === "and" && crudFilter.value.length !== 0)),
+  );
 };
 
 export const unionSorters = (
-    permanentSorter: CrudSorting,
-    newSorters: CrudSorting,
-): CrudSorting =>
-    unionWith(permanentSorter, newSorters, compareSorters).filter(
-        (crudSorter) =>
-            crudSorter.order !== undefined && crudSorter.order !== null,
-    );
+  permanentSorter: CrudSort[],
+  newSorters: CrudSort[],
+): CrudSort[] =>
+  unionWith(permanentSorter, newSorters, compareSorters).filter(
+    (crudSorter) => crudSorter.order !== undefined && crudSorter.order !== null,
+  );
 // Prioritize filters in the permanentFilter and put it at the end of result array
 export const setInitialFilters = (
-    permanentFilter: CrudFilters,
-    defaultFilter: CrudFilters,
-): CrudFilters => [
-    ...differenceWith(defaultFilter, permanentFilter, compareFilters),
-    ...permanentFilter,
+  permanentFilter: CrudFilter[],
+  defaultFilter: CrudFilter[],
+): CrudFilter[] => [
+  ...differenceWith(defaultFilter, permanentFilter, compareFilters),
+  ...permanentFilter,
 ];
 
 export const setInitialSorters = (
-    permanentSorter: CrudSorting,
-    defaultSorter: CrudSorting,
-): CrudSorting => [
-    ...differenceWith(defaultSorter, permanentSorter, compareSorters),
-    ...permanentSorter,
+  permanentSorter: CrudSort[],
+  defaultSorter: CrudSort[],
+): CrudSort[] => [
+  ...differenceWith(defaultSorter, permanentSorter, compareSorters),
+  ...permanentSorter,
 ];
 
 export const getDefaultSortOrder = (
-    columnName: string,
-    sorter?: CrudSorting,
+  columnName: string,
+  sorter?: CrudSort[],
 ): SortOrder | undefined => {
-    if (!sorter) {
-        return undefined;
-    }
+  if (!sorter) {
+    return undefined;
+  }
 
-    const sortItem = sorter.find((item) => item.field === columnName);
+  const sortItem = sorter.find((item) => item.field === columnName);
 
-    if (sortItem) {
-        return sortItem.order as SortOrder;
-    }
+  if (sortItem) {
+    return sortItem.order as SortOrder;
+  }
 
-    return undefined;
+  return undefined;
 };
 
 export const getDefaultFilter = (
-    columnName: string,
-    filters?: CrudFilters,
-    operatorType: CrudOperators = "eq",
+  columnName: string,
+  filters?: CrudFilter[],
+  operatorType: CrudOperators = "eq",
 ): CrudFilter["value"] | undefined => {
-    const filter = filters?.find((filter) => {
-        if (
-            filter.operator !== "or" &&
-            filter.operator !== "and" &&
-            "field" in filter
-        ) {
-            const { operator, field } = filter;
-            return field === columnName && operator === operatorType;
-        }
-        return undefined;
-    });
-
-    if (filter) {
-        return filter.value || [];
+  const filter = filters?.find((filter) => {
+    if (
+      filter.operator !== "or" &&
+      filter.operator !== "and" &&
+      "field" in filter
+    ) {
+      const { operator, field } = filter;
+      return field === columnName && operator === operatorType;
     }
-
     return undefined;
+  });
+
+  if (filter) {
+    return filter.value || [];
+  }
+
+  return undefined;
 };

package/src/definitions/upload/file2Base64/index.ts

@@ -1,21 +1,21 @@
 export const file2Base64 = (file: any): Promise<string> => {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
 
-        const resultHandler = () => {
-            if (reader.result) {
-                reader.removeEventListener("load", resultHandler, false);
+    const resultHandler = () => {
+      if (reader.result) {
+        reader.removeEventListener("load", resultHandler, false);
 
-                resolve(reader.result as string);
-            }
-        };
+        resolve(reader.result as string);
+      }
+    };
 
-        reader.addEventListener("load", resultHandler, false);
+    reader.addEventListener("load", resultHandler, false);
 
-        reader.readAsDataURL(file.originFileObj as Blob);
-        reader.onerror = (error) => {
-            reader.removeEventListener("load", resultHandler, false);
-            return reject(error);
-        };
-    });
+    reader.readAsDataURL(file.originFileObj as Blob);
+    reader.onerror = (error) => {
+      reader.removeEventListener("load", resultHandler, false);
+      return reject(error);
+    };
+  });
 };

package/src/hooks/accessControl/useCan/index.ts

@@ -1,21 +1,25 @@
+import { useContext } from "react";
+
+import { getXRay } from "@refinedev/devtools-internal";
 import {
-    useQuery,
-    UseQueryOptions,
-    UseQueryResult,
+  UseQueryOptions,
+  UseQueryResult,
+  useQuery,
 } from "@tanstack/react-query";
-import { useContext } from "react";
 
 import { AccessControlContext } from "@contexts/accessControl";
 import { sanitizeResource } from "@definitions/helpers/sanitize-resource";
-import { CanParams, CanReturnType } from "../../../interfaces";
 import { useKeys } from "@hooks/useKeys";
-import { getXRay } from "@refinedev/devtools-internal";
+import {
+  CanParams,
+  CanReturnType,
+} from "../../../contexts/accessControl/types";
 
 export type UseCanProps = CanParams & {
-    /**
-     * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options
-     */
-    queryOptions?: UseQueryOptions<CanReturnType>;
+  /**
+   * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options
+   */
+  queryOptions?: UseQueryOptions<CanReturnType>;
 };
 
 /**
@@ -27,58 +31,56 @@ export type UseCanProps = CanParams & {
  *
  */
 export const useCan = ({
-    action,
-    resource,
-    params,
-    queryOptions: hookQueryOptions,
+  action,
+  resource,
+  params,
+  queryOptions: hookQueryOptions,
 }: UseCanProps): UseQueryResult<CanReturnType> => {
-    const { can, options: globalOptions } = useContext(AccessControlContext);
-    const { keys, preferLegacyKeys } = useKeys();
+  const { can, options: globalOptions } = useContext(AccessControlContext);
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const { queryOptions: globalQueryOptions } = globalOptions || {};
+  const { queryOptions: globalQueryOptions } = globalOptions || {};
 
-    const mergedQueryOptions = {
-        ...globalQueryOptions,
-        ...hookQueryOptions,
-    };
+  const mergedQueryOptions = {
+    ...globalQueryOptions,
+    ...hookQueryOptions,
+  };
 
-    /**
-     * Since `react-query` stringifies the query keys, it will throw an error for a circular dependency if we include `React.ReactNode` elements inside the keys.
-     * The feature in #2220(https://github.com/refinedev/refine/issues/2220) includes such change and to fix this, we need to remove `icon` property in the `resource`
-     */
-    const { resource: _resource, ...paramsRest } = params ?? {};
+  /**
+   * Since `react-query` stringifies the query keys, it will throw an error for a circular dependency if we include `React.ReactNode` elements inside the keys.
+   * The feature in #2220(https://github.com/refinedev/refine/issues/2220) includes such change and to fix this, we need to remove `icon` property in the `resource`
+   */
+  const { resource: _resource, ...paramsRest } = params ?? {};
 
-    /* eslint-disable @typescript-eslint/no-unused-vars */
-    const sanitizedResource = sanitizeResource(_resource);
+  const sanitizedResource = sanitizeResource(_resource);
 
-    /* eslint-enable @typescript-eslint/no-unused-vars */
-    const queryResponse = useQuery<CanReturnType>({
-        queryKey: keys()
-            .access()
-            .resource(resource)
-            .action(action)
-            .params({
-                params: { ...paramsRest, resource: sanitizedResource },
-                enabled: mergedQueryOptions?.enabled,
-            })
-            .get(preferLegacyKeys),
-        // Enabled check for `can` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
-        queryFn: () =>
-            can?.({
-                action,
-                resource,
-                params: { ...paramsRest, resource: sanitizedResource },
-            }) ?? Promise.resolve({ can: true }),
-        enabled: typeof can !== "undefined",
-        ...mergedQueryOptions,
-        meta: {
-            ...mergedQueryOptions?.meta,
-            ...getXRay("useCan", preferLegacyKeys),
-        },
-        retry: false,
-    });
+  const queryResponse = useQuery<CanReturnType>({
+    queryKey: keys()
+      .access()
+      .resource(resource)
+      .action(action)
+      .params({
+        params: { ...paramsRest, resource: sanitizedResource },
+        enabled: mergedQueryOptions?.enabled,
+      })
+      .get(preferLegacyKeys),
+    // Enabled check for `can` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
+    queryFn: () =>
+      can?.({
+        action,
+        resource,
+        params: { ...paramsRest, resource: sanitizedResource },
+      }) ?? Promise.resolve({ can: true }),
+    enabled: typeof can !== "undefined",
+    ...mergedQueryOptions,
+    meta: {
+      ...mergedQueryOptions?.meta,
+      ...getXRay("useCan", preferLegacyKeys),
+    },
+    retry: false,
+  });
 
-    return typeof can === "undefined"
-        ? ({ data: { can: true } } as typeof queryResponse)
-        : queryResponse;
+  return typeof can === "undefined"
+    ? ({ data: { can: true } } as typeof queryResponse)
+    : queryResponse;
 };

package/src/hooks/accessControl/useCanWithoutCache.ts

@@ -2,38 +2,38 @@ import React from "react";
 
 import { AccessControlContext } from "@contexts/accessControl";
 import { sanitizeResource } from "@definitions/helpers/sanitize-resource";
-import { IAccessControlContext } from "../../interfaces";
+
+import { IAccessControlContext } from "../../contexts/accessControl/types";
 
 export const useCanWithoutCache = (): IAccessControlContext => {
-    const { can: canFromContext } = React.useContext(AccessControlContext);
-
-    const can = React.useMemo(() => {
-        if (!canFromContext) {
-            return undefined;
-        }
-
-        const canWithSanitizedResource: NonNullable<
-            typeof canFromContext
-        > = async ({ params, ...rest }) => {
-            const sanitizedResource = params?.resource
-                ? sanitizeResource(params.resource)
-                : undefined;
-
-            return canFromContext({
-                ...rest,
-                ...(params
-                    ? {
-                          params: {
-                              ...params,
-                              resource: sanitizedResource,
-                          },
-                      }
-                    : {}),
-            });
-        };
-
-        return canWithSanitizedResource;
-    }, [canFromContext]);
-
-    return { can };
+  const { can: canFromContext } = React.useContext(AccessControlContext);
+
+  const can = React.useMemo(() => {
+    if (!canFromContext) {
+      return undefined;
+    }
+
+    const canWithSanitizedResource: NonNullable<typeof canFromContext> =
+      async ({ params, ...rest }) => {
+        const sanitizedResource = params?.resource
+          ? sanitizeResource(params.resource)
+          : undefined;
+
+        return canFromContext({
+          ...rest,
+          ...(params
+            ? {
+                params: {
+                  ...params,
+                  resource: sanitizedResource,
+                },
+              }
+            : {}),
+        });
+      };
+
+    return canWithSanitizedResource;
+  }, [canFromContext]);
+
+  return { can };
 };