@refinedev/core 4.47.2 → 4.49.0

package/src/definitions/helpers/router/prepare-route-params.ts

@@ -5,16 +5,19 @@
  * This means, we can use `meta` for user supplied params (both manually or from the query string)
  */
 export const prepareRouteParams = <
-    TRouteParams extends Record<string, unknown> = Record<string, unknown>,
+  TRouteParams extends Record<string, unknown> = Record<string, unknown>,
 >(
-    routeParams: (keyof TRouteParams)[],
-    meta: Record<string, unknown> = {},
+  routeParams: (keyof TRouteParams)[],
+  meta: Record<string, unknown> = {},
 ): Partial<TRouteParams> => {
-    return routeParams.reduce((acc, key) => {
-        const value = meta[key as string];
-        if (typeof value !== "undefined") {
-            acc[key] = value as TRouteParams[keyof TRouteParams];
-        }
-        return acc;
-    }, {} as Partial<TRouteParams>);
+  return routeParams.reduce(
+    (acc, key) => {
+      const value = meta[key as string];
+      if (typeof value !== "undefined") {
+        acc[key] = value as TRouteParams[keyof TRouteParams];
+      }
+      return acc;
+    },
+    {} as Partial<TRouteParams>,
+  );
 };

package/src/definitions/helpers/router/remove-leading-trailing-slashes.ts

@@ -2,5 +2,5 @@
  * Remove leading and trailing slashes from a route.
  */
 export const removeLeadingTrailingSlashes = (route: string) => {
-    return route.replace(/^\/|\/$/g, "");
+  return route.replace(/^\/|\/$/g, "");
 };

package/src/definitions/helpers/router/split-to-segments.ts

@@ -2,6 +2,6 @@
  * Split a path to segments.
  */
 export const splitToSegments = (path: string) => {
-    const segments = path.split("/").filter((segment) => segment !== "");
-    return segments;
+  const segments = path.split("/").filter((segment) => segment !== "");
+  return segments;
 };

package/src/definitions/helpers/safe-translate/index.ts

@@ -1,20 +1,20 @@
-import type { useTranslate } from "@hooks/translate";
+import type { useTranslate } from "@hooks/i18n";
 
 export const safeTranslate = (
-    translate: ReturnType<typeof useTranslate>,
-    key: string,
-    defaultMessage?: string,
-    options?: any,
+  translate: ReturnType<typeof useTranslate>,
+  key: string,
+  defaultMessage?: string,
+  options?: any,
 ) => {
-    const translated = options
-        ? translate(key, options, defaultMessage)
-        : translate(key, defaultMessage);
+  const translated = options
+    ? translate(key, options, defaultMessage)
+    : translate(key, defaultMessage);
 
-    const fallback = defaultMessage ?? key;
+  const fallback = defaultMessage ?? key;
 
-    if (translated === key || typeof translated === "undefined") {
-        return fallback;
-    }
+  if (translated === key || typeof translated === "undefined") {
+    return fallback;
+  }
 
-    return translated;
+  return translated;
 };

package/src/definitions/helpers/sanitize-resource/index.ts

@@ -1,38 +1,37 @@
-import { IResourceItem } from "../../../interfaces/bindings/resource";
+import { IResourceItem } from "../../../contexts/resource/types";
 
 /**
  * Remove all properties that are non-serializable from a resource object.
  */
 export const sanitizeResource = (
-    resource?: Partial<IResourceItem> &
-        Required<Pick<IResourceItem, "name">> & { children?: unknown },
+  resource?: Partial<IResourceItem> &
+    Required<Pick<IResourceItem, "name">> & { children?: unknown },
 ):
-    | (Partial<IResourceItem> & Required<Pick<IResourceItem, "name">>)
-    | undefined => {
-    if (!resource) {
-        return undefined;
-    }
+  | (Partial<IResourceItem> & Required<Pick<IResourceItem, "name">>)
+  | undefined => {
+  if (!resource) {
+    return undefined;
+  }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-        icon,
-        list,
-        edit,
-        create,
-        show,
-        clone,
-        children,
-        meta,
-        options,
-        ...restResource
-    } = resource;
+  const {
+    icon,
+    list,
+    edit,
+    create,
+    show,
+    clone,
+    children,
+    meta,
+    options,
+    ...restResource
+  } = resource;
 
-    const { icon: _metaIcon, ...restMeta } = meta ?? {};
-    const { icon: _optionsIcon, ...restOptions } = options ?? {};
+  const { icon: _metaIcon, ...restMeta } = meta ?? {};
+  const { icon: _optionsIcon, ...restOptions } = options ?? {};
 
-    return {
-        ...restResource,
-        ...(meta ? { meta: restMeta } : {}),
-        ...(options ? { options: restOptions } : {}),
-    };
+  return {
+    ...restResource,
+    ...(meta ? { meta: restMeta } : {}),
+    ...(options ? { options: restOptions } : {}),
+  };
 };

package/src/definitions/helpers/sequentialPromises/index.ts

@@ -1,32 +1,32 @@
 type EachResolve<TResolve, Response> = (
-    result: TResolve,
-    index: number,
+  result: TResolve,
+  index: number,
 ) => Response;
 type EachReject<TReject, Response> = (
-    error: TReject,
-    index: number,
+  error: TReject,
+  index: number,
 ) => Response;
 
 export const sequentialPromises = async <
-    TResolve = unknown,
-    TReject = unknown,
-    TResolveResponse = unknown,
-    TRejectResponse = unknown,
+  TResolve = unknown,
+  TReject = unknown,
+  TResolveResponse = unknown,
+  TRejectResponse = unknown,
 >(
-    promises: (() => Promise<TResolve>)[],
-    onEachResolve: EachResolve<TResolve, TResolveResponse>,
-    onEachReject: EachReject<TReject, TRejectResponse>,
+  promises: (() => Promise<TResolve>)[],
+  onEachResolve: EachResolve<TResolve, TResolveResponse>,
+  onEachReject: EachReject<TReject, TRejectResponse>,
 ): Promise<(TResolveResponse | TRejectResponse)[]> => {
-    const results = [];
-    // @ts-expect-error Remove this when we enable `downLevelIterations`
-    for (const [index, promise] of promises.entries()) {
-        try {
-            const result = await promise();
+  const results = [];
+  // @ts-expect-error Remove this when we enable `downLevelIterations`
+  for (const [index, promise] of promises.entries()) {
+    try {
+      const result = await promise();
 
-            results.push(onEachResolve(result, index));
-        } catch (error) {
-            results.push(onEachReject(error as TReject, index));
-        }
+      results.push(onEachResolve(result, index));
+    } catch (error) {
+      results.push(onEachReject(error as TReject, index));
     }
-    return results;
+  }
+  return results;
 };

package/src/definitions/helpers/treeView/createTreeView/index.ts

@@ -1,44 +1,49 @@
 import { pickNotDeprecated } from "@definitions/helpers/pickNotDeprecated";
-import { IResourceItem, ITreeMenu, IMenuItem } from "src/interfaces";
+
+import {
+  IMenuItem,
+  IResourceItem,
+  ITreeMenu,
+} from "../../../../contexts/resource/types";
 
 /**
  * @deprecated This helper is deprecated. Please use `createTree` instead.
  */
 export const createTreeView = (
-    resources: IResourceItem[] | IMenuItem[],
+  resources: IResourceItem[] | IMenuItem[],
 ): ITreeMenu[] | ITreeMenu[] => {
-    const tree = [];
-    const resourcesRouteObject: { [key: string]: any } = {};
-    const resourcesNameObject: { [key: string]: any } = {};
-    let parent: IResourceItem | IMenuItem;
-    let child: ITreeMenu;
-
-    for (let i = 0; i < resources.length; i++) {
-        parent = resources[i];
-
-        const route =
-            parent.route ??
-            pickNotDeprecated(parent?.meta, parent.options)?.route ??
-            "";
-
-        resourcesRouteObject[route] = parent;
-        resourcesRouteObject[route]["children"] = [];
-
-        resourcesNameObject[parent.name] = parent;
-        resourcesNameObject[parent.name]["children"] = [];
-    }
-
-    for (const name in resourcesRouteObject) {
-        if (resourcesRouteObject.hasOwnProperty(name)) {
-            child = resourcesRouteObject[name];
-
-            if (child.parentName && resourcesNameObject[child.parentName]) {
-                resourcesNameObject[child.parentName]["children"].push(child);
-            } else {
-                tree.push(child);
-            }
-        }
+  const tree = [];
+  const resourcesRouteObject: { [key: string]: any } = {};
+  const resourcesNameObject: { [key: string]: any } = {};
+  let parent: IResourceItem | IMenuItem;
+  let child: ITreeMenu;
+
+  for (let i = 0; i < resources.length; i++) {
+    parent = resources[i];
+
+    const route =
+      parent.route ??
+      pickNotDeprecated(parent?.meta, parent.options)?.route ??
+      "";
+
+    resourcesRouteObject[route] = parent;
+    resourcesRouteObject[route]["children"] = [];
+
+    resourcesNameObject[parent.name] = parent;
+    resourcesNameObject[parent.name]["children"] = [];
+  }
+
+  for (const name in resourcesRouteObject) {
+    if (Object.hasOwn(resourcesRouteObject, name)) {
+      child = resourcesRouteObject[name];
+
+      if (child.parentName && resourcesNameObject[child.parentName]) {
+        resourcesNameObject[child.parentName]["children"].push(child);
+      } else {
+        tree.push(child);
+      }
     }
+  }
 
-    return tree;
+  return tree;
 };

package/src/definitions/helpers/useActiveAuthProvider/index.ts

@@ -6,25 +6,25 @@ import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
  * NOTE: Will be removed in v5
  */
 export const useActiveAuthProvider = () => {
-    const legacyAuthProvider = useLegacyAuthContext();
-    const authProvider = useAuthBindingsContext();
+  const legacyAuthProvider = useLegacyAuthContext();
+  const authProvider = useAuthBindingsContext();
 
-    if (authProvider.isProvided) {
-        return { isLegacy: false, ...authProvider };
-    }
+  if (authProvider.isProvided) {
+    return { isLegacy: false, ...authProvider };
+  }
 
-    if (legacyAuthProvider.isProvided) {
-        // legacyAuthProvider interface is different from authProvider interface
-        // we need to convert it to authProvider interface for simple usage
-        // in the future, we will remove legacyAuthProvider
-        return {
-            isLegacy: true,
-            ...legacyAuthProvider,
-            check: legacyAuthProvider.checkAuth,
-            onError: legacyAuthProvider.checkError,
-            getIdentity: legacyAuthProvider.getUserIdentity,
-        };
-    }
+  if (legacyAuthProvider.isProvided) {
+    // legacyAuthProvider interface is different from authProvider interface
+    // we need to convert it to authProvider interface for simple usage
+    // in the future, we will remove legacyAuthProvider
+    return {
+      isLegacy: true,
+      ...legacyAuthProvider,
+      check: legacyAuthProvider.checkAuth,
+      onError: legacyAuthProvider.checkError,
+      getIdentity: legacyAuthProvider.getUserIdentity,
+    };
+  }
 
-    return null;
+  return null;
 };

package/src/definitions/helpers/useInfinitePagination/index.ts

@@ -1,30 +1,30 @@
-import { GetListResponse } from "../../../interfaces";
+import { GetListResponse } from "../../../contexts/data/types";
 
 export const getNextPageParam = (lastPage: GetListResponse) => {
-    const { pagination, cursor } = lastPage;
+  const { pagination, cursor } = lastPage;
 
-    // cursor pagination
-    if (cursor?.next) {
-        return cursor.next;
-    }
+  // cursor pagination
+  if (cursor?.next) {
+    return cursor.next;
+  }
 
-    const current = pagination?.current || 1;
+  const current = pagination?.current || 1;
 
-    const pageSize = pagination?.pageSize || 10;
-    const totalPages = Math.ceil((lastPage.total || 0) / pageSize);
+  const pageSize = pagination?.pageSize || 10;
+  const totalPages = Math.ceil((lastPage.total || 0) / pageSize);
 
-    return current < totalPages ? Number(current) + 1 : undefined;
+  return current < totalPages ? Number(current) + 1 : undefined;
 };
 
 export const getPreviousPageParam = (lastPage: GetListResponse) => {
-    const { pagination, cursor } = lastPage;
+  const { pagination, cursor } = lastPage;
 
-    // cursor pagination
-    if (cursor?.prev) {
-        return cursor.prev;
-    }
+  // cursor pagination
+  if (cursor?.prev) {
+    return cursor.prev;
+  }
 
-    const current = pagination?.current || 1;
+  const current = pagination?.current || 1;
 
-    return current === 1 ? undefined : current - 1;
+  return current === 1 ? undefined : current - 1;
 };

package/src/definitions/helpers/useMediaQuery/index.ts

@@ -1,17 +1,17 @@
 import { useState, useEffect } from "react";
 
 export const useMediaQuery = (query: string) => {
-    const [matches, setMatches] = useState(false);
+  const [matches, setMatches] = useState(false);
 
-    useEffect(() => {
-        const media = window.matchMedia(query);
-        if (media.matches !== matches) {
-            setMatches(media.matches);
-        }
-        const listener = () => setMatches(media.matches);
-        window.addEventListener("resize", listener);
-        return () => window.removeEventListener("resize", listener);
-    }, [matches, query]);
+  useEffect(() => {
+    const media = window.matchMedia(query);
+    if (media.matches !== matches) {
+      setMatches(media.matches);
+    }
+    const listener = () => setMatches(media.matches);
+    window.addEventListener("resize", listener);
+    return () => window.removeEventListener("resize", listener);
+  }, [matches, query]);
 
-    return matches;
+  return matches;
 };

package/src/definitions/helpers/useUserFriendlyName/index.ts

@@ -5,20 +5,17 @@ import { useRefineContext } from "@hooks/refine";
  * @internal
  */
 export const useUserFriendlyName = () => {
-    const {
-        options: { textTransformers },
-    } = useRefineContext();
+  const {
+    options: { textTransformers },
+  } = useRefineContext();
 
-    const getFriendlyName = (
-        name = "",
-        type: "singular" | "plural",
-    ): string => {
-        const humanizeName = textTransformers.humanize(name);
-        if (type === "singular") {
-            return textTransformers.singular(humanizeName);
-        }
-        return textTransformers.plural(humanizeName);
-    };
+  const getFriendlyName = (name = "", type: "singular" | "plural"): string => {
+    const humanizeName = textTransformers.humanize(name);
+    if (type === "singular") {
+      return textTransformers.singular(humanizeName);
+    }
+    return textTransformers.plural(humanizeName);
+  };
 
-    return getFriendlyName;
+  return getFriendlyName;
 };

package/src/definitions/helpers/userFriendlyResourceName/index.ts

@@ -7,12 +7,12 @@ import { humanizeString } from "@definitions";
  * @deprecated use `useUserFriendlyName` instead.
  */
 export const userFriendlyResourceName = (
-    resource = "",
-    type: "singular" | "plural",
+  resource = "",
+  type: "singular" | "plural",
 ): string => {
-    const humanizeResource = humanizeString(resource);
-    if (type === "singular") {
-        return pluralize.singular(humanizeResource);
-    }
-    return pluralize.plural(humanizeResource);
+  const humanizeResource = humanizeString(resource);
+  if (type === "singular") {
+    return pluralize.singular(humanizeResource);
+  }
+  return pluralize.plural(humanizeResource);
 };

package/src/definitions/helpers/userFriendlySeconds/index.ts

@@ -1,3 +1,3 @@
 export const userFriendlySecond = (miliseconds: number): number => {
-    return miliseconds / 1000; //convert to seconds
+  return miliseconds / 1000; //convert to seconds
 };