@refinedev/core 4.47.2 → 4.48.0

package/src/hooks/resource/useResource/index.ts

@@ -2,10 +2,10 @@ import { useContext } from "react";
 
 import { ResourceContext } from "@contexts/resource";
 import {
-    Action,
-    BaseKey,
-    IResourceItem,
-    ResourceRouterParams,
+  Action,
+  BaseKey,
+  IResourceItem,
+  ResourceRouterParams,
 } from "../../../interfaces";
 import { useRouterContext, useResourceWithRoute } from "@hooks";
 import { useRouterType } from "../../../contexts/router-picker";
@@ -13,21 +13,21 @@ import { useParsed } from "../../router/use-parsed";
 import { pickResource } from "../../../definitions/helpers/pick-resource";
 
 export type UseResourceLegacyProps = {
-    /**
-     * Determines which resource to use for redirection
-     * @deprecated resourceName deprecated. Use resourceNameOrRouteName instead # https://github.com/refinedev/refine/issues/1618
-     */
-    resourceName?: string;
-    /**
-     * Determines which resource to use for redirection
-     * @default Resource name that it reads from route
-     */
-    resourceNameOrRouteName?: string;
-    /**
-     * Adds id to the end of the URL
-     * @deprecated resourceName deprecated. Use resourceNameOrRouteName instead # https://github.com/refinedev/refine/issues/1618
-     */
-    recordItemId?: BaseKey;
+  /**
+   * Determines which resource to use for redirection
+   * @deprecated resourceName deprecated. Use resourceNameOrRouteName instead # https://github.com/refinedev/refine/issues/1618
+   */
+  resourceName?: string;
+  /**
+   * Determines which resource to use for redirection
+   * @default Resource name that it reads from route
+   */
+  resourceNameOrRouteName?: string;
+  /**
+   * Adds id to the end of the URL
+   * @deprecated resourceName deprecated. Use resourceNameOrRouteName instead # https://github.com/refinedev/refine/issues/1618
+   */
+  recordItemId?: BaseKey;
 };
 
 /**
@@ -38,161 +38,156 @@ export type UseResourceLegacyProps = {
 export type UseResourceParam = string | undefined;
 
 type SelectReturnType<T extends boolean> = T extends true
-    ? { resource: IResourceItem; identifier: string }
-    : { resource: IResourceItem; identifier: string } | undefined;
+  ? { resource: IResourceItem; identifier: string }
+  : { resource: IResourceItem; identifier: string } | undefined;
 
 export type UseResourceReturnType = {
-    resources: IResourceItem[];
-    resource?: IResourceItem;
-    /**
-     * @deprecated Use `resource.name` instead when you need to get the resource name.
-     */
-    resourceName?: string;
-    id?: BaseKey;
-    action?: Action;
-    select: <T extends boolean = true>(
-        resourceName: string,
-        force?: T,
-    ) => SelectReturnType<T>;
-    identifier?: string;
+  resources: IResourceItem[];
+  resource?: IResourceItem;
+  /**
+   * @deprecated Use `resource.name` instead when you need to get the resource name.
+   */
+  resourceName?: string;
+  id?: BaseKey;
+  action?: Action;
+  select: <T extends boolean = true>(
+    resourceName: string,
+    force?: T,
+  ) => SelectReturnType<T>;
+  identifier?: string;
 };
 
 type UseResourceReturnTypeWithResource = UseResourceReturnType & {
-    resource: IResourceItem;
-    identifier: string;
+  resource: IResourceItem;
+  identifier: string;
 };
 
 /**
  * @deprecated Use `useResource` with `identifier` property instead. (`identifier` does not check by route name in new router)
  */
 export function useResource(
-    props: UseResourceLegacyProps,
+  props: UseResourceLegacyProps,
 ): UseResourceReturnType;
 export function useResource(): UseResourceReturnType;
 export function useResource<TIdentifier = UseResourceParam>(
-    identifier: TIdentifier,
+  identifier: TIdentifier,
 ): TIdentifier extends NonNullable<UseResourceParam>
-    ? UseResourceReturnTypeWithResource
-    : UseResourceReturnType;
+  ? UseResourceReturnTypeWithResource
+  : UseResourceReturnType;
 /**
  * `useResource` is used to get `resources` that are defined as property of the `<Refine>` component.
  *
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/resource/useResource} for more details.
  */
 export function useResource(
-    args?: UseResourceLegacyProps | UseResourceParam,
+  args?: UseResourceLegacyProps | UseResourceParam,
 ): UseResourceReturnType {
-    const { resources } = useContext(ResourceContext);
+  const { resources } = useContext(ResourceContext);
+
+  const routerType = useRouterType();
+
+  const params = useParsed();
+
+  const oldProps = {
+    resourceName: args && typeof args !== "string" ? args.resourceName : args,
+    resourceNameOrRouteName:
+      args && typeof args !== "string" ? args.resourceNameOrRouteName : args,
+    recordItemId:
+      args && typeof args !== "string" ? args.recordItemId : undefined,
+  };
+
+  const select = <T extends boolean = true>(
+    resourceName: string,
+    force = true,
+  ): SelectReturnType<T> => {
+    const isLegacy = routerType === "legacy";
+    const pickedResource = pickResource(resourceName, resources, isLegacy);
+
+    if (pickedResource) {
+      return {
+        resource: pickedResource,
+        identifier: pickedResource.identifier ?? pickedResource.name,
+      } as SelectReturnType<T>;
+    }
 
-    const routerType = useRouterType();
+    if (force) {
+      const resource: IResourceItem = {
+        name: resourceName,
+        identifier: resourceName,
+      };
 
-    const params = useParsed();
+      const identifier = resource.identifier ?? resource.name;
 
-    const oldProps = {
-        resourceName:
-            args && typeof args !== "string" ? args.resourceName : args,
-        resourceNameOrRouteName:
-            args && typeof args !== "string"
-                ? args.resourceNameOrRouteName
-                : args,
-        recordItemId:
-            args && typeof args !== "string" ? args.recordItemId : undefined,
-    };
+      return {
+        resource,
+        identifier,
+      } as SelectReturnType<T>;
+    }
 
-    const select = <T extends boolean = true>(
-        resourceName: string,
-        force = true,
-    ): SelectReturnType<T> => {
-        const isLegacy = routerType === "legacy";
-        const pickedResource = pickResource(resourceName, resources, isLegacy);
-
-        if (pickedResource) {
-            return {
-                resource: pickedResource,
-                identifier: pickedResource.identifier ?? pickedResource.name,
-            } as SelectReturnType<T>;
-        }
-
-        if (force) {
-            const resource: IResourceItem = {
-                name: resourceName,
-                identifier: resourceName,
-            };
-
-            const identifier = resource.identifier ?? resource.name;
-
-            return {
-                resource,
-                identifier,
-            } as SelectReturnType<T>;
-        }
-
-        return undefined as SelectReturnType<T>;
-    };
+    return undefined as SelectReturnType<T>;
+  };
 
-    /**
-     * Legacy Router - Start
-     *
-     * using `useParams` and `route` to match resource and get params.
-     */
-    const resourceWithRoute = useResourceWithRoute();
-
-    const { useParams } = useRouterContext();
-
-    const legacyParams = useParams<Partial<ResourceRouterParams>>();
-
-    if (routerType === "legacy") {
-        const resourceKeyToCheck = oldProps.resourceNameOrRouteName
-            ? oldProps.resourceNameOrRouteName
-            : legacyParams.resource;
-
-        const legacyResource = resourceKeyToCheck
-            ? resourceWithRoute(resourceKeyToCheck)
-            : undefined;
-        const legacyId = oldProps?.recordItemId ?? legacyParams.id;
-        const legacyAction = legacyParams.action;
-        const legacyResourceName =
-            oldProps?.resourceName ?? legacyResource?.name;
-        const legacyIdentifier =
-            legacyResource?.identifier ?? legacyResource?.name;
-
-        return {
-            resources,
-            resource: legacyResource,
-            resourceName: legacyResourceName,
-            id: legacyId,
-            action: legacyAction,
-            select,
-            identifier: legacyIdentifier,
-        };
-    }
-    /** Legacy Router - End */
-
-    /** New Router */
-    let resource: IResourceItem | undefined = undefined;
-    // we try to pick the resource from props first
-    const identifier =
-        typeof args === "string" ? args : oldProps?.resourceNameOrRouteName;
-    if (identifier) {
-        const pickedFromProps = pickResource(identifier, resources);
-        if (pickedFromProps) {
-            resource = pickedFromProps;
-        } else {
-            resource = {
-                name: identifier as string,
-            };
-        }
-    } else if (params?.resource) {
-        resource = params.resource;
-    }
+  /**
+   * Legacy Router - Start
+   *
+   * using `useParams` and `route` to match resource and get params.
+   */
+  const resourceWithRoute = useResourceWithRoute();
+
+  const { useParams } = useRouterContext();
+
+  const legacyParams = useParams<Partial<ResourceRouterParams>>();
+
+  if (routerType === "legacy") {
+    const resourceKeyToCheck = oldProps.resourceNameOrRouteName
+      ? oldProps.resourceNameOrRouteName
+      : legacyParams.resource;
+
+    const legacyResource = resourceKeyToCheck
+      ? resourceWithRoute(resourceKeyToCheck)
+      : undefined;
+    const legacyId = oldProps?.recordItemId ?? legacyParams.id;
+    const legacyAction = legacyParams.action;
+    const legacyResourceName = oldProps?.resourceName ?? legacyResource?.name;
+    const legacyIdentifier = legacyResource?.identifier ?? legacyResource?.name;
 
     return {
-        resources,
-        resource,
-        resourceName: resource?.name,
-        id: params.id,
-        action: params.action,
-        select,
-        identifier: resource?.identifier ?? resource?.name,
+      resources,
+      resource: legacyResource,
+      resourceName: legacyResourceName,
+      id: legacyId,
+      action: legacyAction,
+      select,
+      identifier: legacyIdentifier,
     };
+  }
+  /** Legacy Router - End */
+
+  /** New Router */
+  let resource: IResourceItem | undefined = undefined;
+  // we try to pick the resource from props first
+  const identifier =
+    typeof args === "string" ? args : oldProps?.resourceNameOrRouteName;
+  if (identifier) {
+    const pickedFromProps = pickResource(identifier, resources);
+    if (pickedFromProps) {
+      resource = pickedFromProps;
+    } else {
+      resource = {
+        name: identifier as string,
+      };
+    }
+  } else if (params?.resource) {
+    resource = params.resource;
+  }
+
+  return {
+    resources,
+    resource,
+    resourceName: resource?.name,
+    id: params.id,
+    action: params.action,
+    select,
+    identifier: resource?.identifier ?? resource?.name,
+  };
 }

package/src/hooks/resource/useResourceWithRoute/index.ts

@@ -10,18 +10,18 @@ export type UseResourceWithRouteReturnType = (route: string) => IResourceItem;
  * @internal This hook is for internal use only. And is kept for backward compatibility.
  */
 export const useResourceWithRoute = (): UseResourceWithRouteReturnType => {
-    const { resources } = useContext(ResourceContext);
+  const { resources } = useContext(ResourceContext);
 
-    const resourceWithRoute = useCallback(
-        (route: string) => {
-            const picked = pickResource(route, resources, true);
-            if (picked) {
-                return picked;
-            }
-            return { name: route, route: route } as IResourceItem;
-        },
-        [resources],
-    );
+  const resourceWithRoute = useCallback(
+    (route: string) => {
+      const picked = pickResource(route, resources, true);
+      if (picked) {
+        return picked;
+      }
+      return { name: route, route: route } as IResourceItem;
+    },
+    [resources],
+  );
 
-    return resourceWithRoute;
+  return resourceWithRoute;
 };

package/src/hooks/router/use-back/index.tsx

@@ -2,14 +2,14 @@ import { RouterBindingsContext } from "@contexts/router";
 import React, { useContext } from "react";
 
 export const useBack = () => {
-    const bindings = useContext(RouterBindingsContext);
+  const bindings = useContext(RouterBindingsContext);
 
-    const useBack = React.useMemo(
-        () => bindings?.back ?? (() => () => undefined),
-        [bindings?.back],
-    );
+  const useBack = React.useMemo(
+    () => bindings?.back ?? (() => () => undefined),
+    [bindings?.back],
+  );
 
-    const back = useBack();
+  const back = useBack();
 
-    return back;
+  return back;
 };

package/src/hooks/router/use-get-to-path/index.ts

@@ -7,10 +7,10 @@ import { composeRoute } from "../../../definitions/helpers/router/compose-route"
 import { useRouterType } from "./../../../contexts/router-picker";
 
 type UseToPathParams = {
-    resource?: IResourceItem;
-    action: Action;
-    meta?: Record<string, unknown>;
-    legacy?: boolean;
+  resource?: IResourceItem;
+  action: Action;
+  meta?: Record<string, unknown>;
+  legacy?: boolean;
 };
 
 type GetToPathFn = (params: UseToPathParams) => string | undefined;
@@ -23,43 +23,43 @@ type GetToPathFn = (params: UseToPathParams) => string | undefined;
  * `meta` can be provided to compose the routes with parameters. (Can be used for nested routes.)
  */
 export const useGetToPath = (): GetToPathFn => {
-    const routerType = useRouterType();
-    const { resource: resourceFromRoute, resources } = useResource();
-    const parsed = useParsed();
+  const routerType = useRouterType();
+  const { resource: resourceFromRoute, resources } = useResource();
+  const parsed = useParsed();
 
-    const fn = React.useCallback(
-        ({ resource, action, meta }: UseToPathParams): string | undefined => {
-            const selectedResource = resource || resourceFromRoute;
+  const fn = React.useCallback(
+    ({ resource, action, meta }: UseToPathParams): string | undefined => {
+      const selectedResource = resource || resourceFromRoute;
 
-            if (!selectedResource) {
-                return undefined;
-            }
+      if (!selectedResource) {
+        return undefined;
+      }
 
-            const actionRoutes = getActionRoutesFromResource(
-                selectedResource,
-                resources,
-                routerType === "legacy",
-            );
+      const actionRoutes = getActionRoutesFromResource(
+        selectedResource,
+        resources,
+        routerType === "legacy",
+      );
 
-            const actionRoute = actionRoutes.find(
-                (item) => item.action === action,
-            )?.route;
+      const actionRoute = actionRoutes.find(
+        (item) => item.action === action,
+      )?.route;
 
-            if (!actionRoute) {
-                return undefined;
-            }
+      if (!actionRoute) {
+        return undefined;
+      }
 
-            const composed = composeRoute(
-                actionRoute,
-                selectedResource?.meta,
-                parsed,
-                meta,
-            );
+      const composed = composeRoute(
+        actionRoute,
+        selectedResource?.meta,
+        parsed,
+        meta,
+      );
 
-            return composed;
-        },
-        [resources, resourceFromRoute, parsed],
-    );
+      return composed;
+    },
+    [resources, resourceFromRoute, parsed],
+  );
 
-    return fn;
+  return fn;
 };

package/src/hooks/router/use-go/index.tsx

@@ -2,79 +2,79 @@ import { RouterBindingsContext } from "@contexts/router";
 import { useResource } from "@hooks/resource";
 import React, { useCallback, useContext } from "react";
 import type {
-    Action,
-    BaseKey,
-    GoConfig as GoConfigBase,
-    IResourceItem,
+  Action,
+  BaseKey,
+  GoConfig as GoConfigBase,
+  IResourceItem,
 } from "../../../interfaces";
 import { useGetToPath } from "../use-get-to-path";
 
 type ResourceWithoutId = {
-    /**
-     *  The name or identifier of the resource.
-     */
-    resource: string;
-    action: Extract<Action, "create" | "list">;
-    id?: never;
-    meta?: Record<string, unknown>;
+  /**
+   *  The name or identifier of the resource.
+   */
+  resource: string;
+  action: Extract<Action, "create" | "list">;
+  id?: never;
+  meta?: Record<string, unknown>;
 };
 
 type ResourceWithId = {
-    /**
-     *  The name or identifier of the resource.
-     */
-    resource: string;
-    action: Extract<Action, "edit" | "show" | "clone">;
-    id: BaseKey;
-    meta?: Record<string, unknown>;
+  /**
+   *  The name or identifier of the resource.
+   */
+  resource: string;
+  action: Extract<Action, "edit" | "show" | "clone">;
+  id: BaseKey;
+  meta?: Record<string, unknown>;
 };
 
 export type Resource = ResourceWithoutId | ResourceWithId;
 
 export type GoConfigWithResource = Omit<GoConfigBase, "to"> & {
-    to?: GoConfigBase["to"] | Resource;
+  to?: GoConfigBase["to"] | Resource;
 };
 
 export const useGo = () => {
-    const bindings = useContext(RouterBindingsContext);
-    const { select: resourceSelect } = useResource();
-    const getToPath = useGetToPath();
+  const bindings = useContext(RouterBindingsContext);
+  const { select: resourceSelect } = useResource();
+  const getToPath = useGetToPath();
 
-    const useGo = React.useMemo(
-        () => bindings?.go ?? (() => () => undefined),
-        [bindings?.go],
-    );
-
-    const goFromRouter = useGo();
+  const useGo = React.useMemo(
+    () => bindings?.go ?? (() => () => undefined),
+    [bindings?.go],
+  );
 
-    const go = useCallback(
-        (config: GoConfigWithResource | GoConfigBase) => {
-            if (typeof config.to !== "object") {
-                return goFromRouter({ ...config, to: config.to });
-            }
+  const goFromRouter = useGo();
 
-            // when config.to is an object, it means that we want to go to a resource.
-            // so we need to find the path for the resource.
-            const { resource } = resourceSelect(config.to.resource);
-            handleResourceErrors(config.to, resource);
-            const newTo = getToPath({
-                resource,
-                action: config.to.action,
-                meta: {
-                    id: config.to.id,
-                    ...config.to.meta,
-                },
-            });
+  const go = useCallback(
+    (config: GoConfigWithResource | GoConfigBase) => {
+      if (typeof config.to !== "object") {
+        return goFromRouter({ ...config, to: config.to });
+      }
 
-            return goFromRouter({
-                ...config,
-                to: newTo,
-            });
+      // when config.to is an object, it means that we want to go to a resource.
+      // so we need to find the path for the resource.
+      const { resource } = resourceSelect(config.to.resource);
+      handleResourceErrors(config.to, resource);
+      const newTo = getToPath({
+        resource,
+        action: config.to.action,
+        meta: {
+          id: config.to.id,
+          ...config.to.meta,
         },
-        [resourceSelect, goFromRouter],
-    );
+      });
 
-    return go;
+      return goFromRouter({
+        ...config,
+        to: newTo,
+      });
+    },
+    [resourceSelect, goFromRouter],
+  );
+
+  return go;
 };
 
 /**
@@ -82,20 +82,20 @@ export const useGo = () => {
  * @internal
  */
 export const handleResourceErrors = (to: Resource, resource: IResourceItem) => {
-    if (!to?.action || !to?.resource) {
-        throw new Error(`[useGo]: "action" or "resource" is required.`);
-    }
+  if (!to?.action || !to?.resource) {
+    throw new Error(`[useGo]: "action" or "resource" is required.`);
+  }
 
-    if (["edit", "show", "clone"].includes(to?.action) && !to.id) {
-        throw new Error(
-            `[useGo]: [action: ${to.action}] requires an "id" for resource [resource: ${to.resource}]`,
-        );
-    }
+  if (["edit", "show", "clone"].includes(to?.action) && !to.id) {
+    throw new Error(
+      `[useGo]: [action: ${to.action}] requires an "id" for resource [resource: ${to.resource}]`,
+    );
+  }
 
-    const actionUrl = resource[to.action];
-    if (!actionUrl) {
-        throw new Error(
-            `[useGo]: [action: ${to.action}] is not defined for [resource: ${to.resource}]`,
-        );
-    }
+  const actionUrl = resource[to.action];
+  if (!actionUrl) {
+    throw new Error(
+      `[useGo]: [action: ${to.action}] is not defined for [resource: ${to.resource}]`,
+    );
+  }
 };

package/src/hooks/router/use-link/index.tsx

@@ -2,16 +2,15 @@ import { RouterBindingsContext } from "@contexts/router";
 import React, { useContext } from "react";
 
 export const useLink = () => {
-    const bindings = useContext(RouterBindingsContext);
+  const bindings = useContext(RouterBindingsContext);
 
-    if (bindings?.Link) {
-        return bindings.Link;
-    }
+  if (bindings?.Link) {
+    return bindings.Link;
+  }
 
-    const FallbackLink: Required<typeof bindings>["Link"] = ({
-        to,
-        ...rest
-    }) => <a href={to} {...rest} />;
+  const FallbackLink: Required<typeof bindings>["Link"] = ({ to, ...rest }) => (
+    <a href={to} {...rest} />
+  );
 
-    return FallbackLink;
+  return FallbackLink;
 };