@refinedev/core 4.47.2 → 4.48.0

package/src/definitions/helpers/router/__tests__/get-parent-prefix-for-resource.ts

@@ -1,84 +1,80 @@
 import { getParentPrefixForResource } from "../get-parent-prefix-for-resource";
 
 describe("getParentPrefixForResource", () => {
-    it("should return undefined if no parent is found", () => {
-        const resources = [
-            {
-                name: "users",
-            },
-        ];
+  it("should return undefined if no parent is found", () => {
+    const resources = [
+      {
+        name: "users",
+      },
+    ];
 
-        expect(getParentPrefixForResource(resources[0], resources)).toBe(
-            undefined,
-        );
-    });
+    expect(getParentPrefixForResource(resources[0], resources)).toBe(undefined);
+  });
 
-    it("should return the parent prefix", () => {
-        const resources = [
-            {
-                name: "users",
-            },
-            {
-                name: "posts",
-                meta: {
-                    parent: "users",
-                },
-            },
-        ];
+  it("should return the parent prefix", () => {
+    const resources = [
+      {
+        name: "users",
+      },
+      {
+        name: "posts",
+        meta: {
+          parent: "users",
+        },
+      },
+    ];
 
-        expect(getParentPrefixForResource(resources[1], resources)).toBe(
-            "/users",
-        );
-    });
+    expect(getParentPrefixForResource(resources[1], resources)).toBe("/users");
+  });
 
-    it("should return the parent prefix for deeply nested resources", () => {
-        const resources = [
-            {
-                name: "users",
-            },
-            {
-                name: "posts",
-                meta: {
-                    parent: "users",
-                },
-            },
-            {
-                name: "comments",
-                meta: {
-                    parent: "posts",
-                },
-            },
-        ];
+  it("should return the parent prefix for deeply nested resources", () => {
+    const resources = [
+      {
+        name: "users",
+      },
+      {
+        name: "posts",
+        meta: {
+          parent: "users",
+        },
+      },
+      {
+        name: "comments",
+        meta: {
+          parent: "posts",
+        },
+      },
+    ];
 
-        expect(getParentPrefixForResource(resources[2], resources)).toBe(
-            "/users/posts",
-        );
-    });
+    expect(getParentPrefixForResource(resources[2], resources)).toBe(
+      "/users/posts",
+    );
+  });
 
-    it("should return the parent prefix for deeply nested resources with legacy routes", () => {
-        const resources = [
-            {
-                name: "users",
-                options: {
-                    route: "custom-users",
-                },
-            },
-            {
-                name: "posts",
-                meta: {
-                    parent: "users",
-                },
-            },
-            {
-                name: "comments",
-                meta: {
-                    parent: "posts",
-                },
-            },
-        ];
+  it("should return the parent prefix for deeply nested resources with legacy routes", () => {
+    const resources = [
+      {
+        name: "users",
+        options: {
+          route: "custom-users",
+        },
+      },
+      {
+        name: "posts",
+        meta: {
+          parent: "users",
+        },
+      },
+      {
+        name: "comments",
+        meta: {
+          parent: "posts",
+        },
+      },
+    ];
 
-        expect(getParentPrefixForResource(resources[2], resources, true)).toBe(
-            "/custom-users/posts",
-        );
-    });
+    expect(getParentPrefixForResource(resources[2], resources, true)).toBe(
+      "/custom-users/posts",
+    );
+  });
 });

package/src/definitions/helpers/router/__tests__/get-parent-resource.ts

@@ -1,51 +1,51 @@
 import { getParentResource } from "../get-parent-resource";
 
 describe("getParentResource", () => {
-    it("should return undefined if no parent is given", () => {
-        const result = getParentResource(
-            {
-                name: "users",
-                meta: {},
-            },
-            [],
-        );
+  it("should return undefined if no parent is given", () => {
+    const result = getParentResource(
+      {
+        name: "users",
+        meta: {},
+      },
+      [],
+    );
 
-        expect(result).toEqual(undefined);
-    });
+    expect(result).toEqual(undefined);
+  });
 
-    it("should return the parent resource if parent is given", () => {
-        const result = getParentResource(
-            {
-                name: "users",
-                meta: {
-                    parent: "orgs",
-                },
-            },
-            [
-                {
-                    name: "orgs",
-                },
-            ],
-        );
+  it("should return the parent resource if parent is given", () => {
+    const result = getParentResource(
+      {
+        name: "users",
+        meta: {
+          parent: "orgs",
+        },
+      },
+      [
+        {
+          name: "orgs",
+        },
+      ],
+    );
 
-        expect(result).toEqual({
-            name: "orgs",
-        });
+    expect(result).toEqual({
+      name: "orgs",
     });
+  });
 
-    it("should return the parent resource if parent is given even if the parent is not defined", () => {
-        const result = getParentResource(
-            {
-                name: "users",
-                options: {
-                    parent: "orgs",
-                },
-            },
-            [],
-        );
+  it("should return the parent resource if parent is given even if the parent is not defined", () => {
+    const result = getParentResource(
+      {
+        name: "users",
+        options: {
+          parent: "orgs",
+        },
+      },
+      [],
+    );
 
-        expect(result).toEqual({
-            name: "orgs",
-        });
+    expect(result).toEqual({
+      name: "orgs",
     });
+  });
 });

package/src/definitions/helpers/router/__tests__/is-segment-counts-same.ts

@@ -1,21 +1,18 @@
 import { isSegmentCountsSame } from "../is-segment-counts-same";
 
 describe("isSegmentCountsSame", () => {
-    it("should return true if the route and resourceRoute have the same number of segments", () => {
-        const result = isSegmentCountsSame(
-            "/users/edit/123",
-            "/users/edit/:id",
-        );
+  it("should return true if the route and resourceRoute have the same number of segments", () => {
+    const result = isSegmentCountsSame("/users/edit/123", "/users/edit/:id");
 
-        expect(result).toEqual(true);
-    });
+    expect(result).toEqual(true);
+  });
 
-    it("should return false if the route and resourceRoute don't have the same number of segments", () => {
-        const result = isSegmentCountsSame(
-            "/users/edit/123",
-            "users/posts/edit/:id/",
-        );
+  it("should return false if the route and resourceRoute don't have the same number of segments", () => {
+    const result = isSegmentCountsSame(
+      "/users/edit/123",
+      "users/posts/edit/:id/",
+    );
 
-        expect(result).toEqual(false);
-    });
+    expect(result).toEqual(false);
+  });
 });

package/src/definitions/helpers/router/__tests__/match-resource-from-route.ts

@@ -1,59 +1,59 @@
 import { matchResourceFromRoute } from "../match-resource-from-route";
 
 describe("matchResourceFromRoute", () => {
-    it("should return found false if no resource is given", () => {
-        const result = matchResourceFromRoute("/users", []);
-
-        expect(result.found).toEqual(false);
-    });
-
-    it("should return found false if no route is given", () => {
-        const result = matchResourceFromRoute("", [
-            {
-                name: "users",
-                edit: {
-                    path: "/users/edit/:id",
-                    component: () => null,
-                },
-            },
-        ]);
-
-        expect(result.found).toEqual(false);
-    });
-
-    it("should return found true if route is found", () => {
-        const result = matchResourceFromRoute("/users/edit/123", [
-            {
-                name: "users",
-                edit: {
-                    path: "/users/edit/:id",
-                    component: () => null,
-                },
-            },
-        ]);
-
-        expect(result.found).toEqual(true);
-    });
-
-    it("should return the best one if multiple routes are found", () => {
-        const result = matchResourceFromRoute("/users/orgs/edit/123", [
-            {
-                name: "users",
-                edit: {
-                    path: "/users/:type/edit/:id",
-                    component: () => null,
-                },
-            },
-            {
-                name: "org-users",
-                edit: {
-                    path: "/users/orgs/edit/:id",
-                    component: () => null,
-                },
-            },
-        ]);
-
-        expect(result.found).toEqual(true);
-        expect(result.matchedRoute).toEqual("/users/orgs/edit/:id");
-    });
+  it("should return found false if no resource is given", () => {
+    const result = matchResourceFromRoute("/users", []);
+
+    expect(result.found).toEqual(false);
+  });
+
+  it("should return found false if no route is given", () => {
+    const result = matchResourceFromRoute("", [
+      {
+        name: "users",
+        edit: {
+          path: "/users/edit/:id",
+          component: () => null,
+        },
+      },
+    ]);
+
+    expect(result.found).toEqual(false);
+  });
+
+  it("should return found true if route is found", () => {
+    const result = matchResourceFromRoute("/users/edit/123", [
+      {
+        name: "users",
+        edit: {
+          path: "/users/edit/:id",
+          component: () => null,
+        },
+      },
+    ]);
+
+    expect(result.found).toEqual(true);
+  });
+
+  it("should return the best one if multiple routes are found", () => {
+    const result = matchResourceFromRoute("/users/orgs/edit/123", [
+      {
+        name: "users",
+        edit: {
+          path: "/users/:type/edit/:id",
+          component: () => null,
+        },
+      },
+      {
+        name: "org-users",
+        edit: {
+          path: "/users/orgs/edit/:id",
+          component: () => null,
+        },
+      },
+    ]);
+
+    expect(result.found).toEqual(true);
+    expect(result.matchedRoute).toEqual("/users/orgs/edit/:id");
+  });
 });

package/src/definitions/helpers/router/__tests__/pick-matched-route.ts

@@ -1,89 +1,89 @@
 import { pickMatchedRoute } from "../pick-matched-route";
 
 describe("pickMatchedRoute", () => {
-    it("should return the route with no params", () => {
-        const routes = [
-            {
-                route: "/users/edit/123",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "users/:action/:id/",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "/users/:action/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "/users/edit/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-        ];
+  it("should return the route with no params", () => {
+    const routes = [
+      {
+        route: "/users/edit/123",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "users/:action/:id/",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "/users/:action/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "/users/edit/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+    ];
 
-        const picked = pickMatchedRoute(routes);
+    const picked = pickMatchedRoute(routes);
 
-        expect(picked?.route).toEqual("/users/edit/123");
-    });
+    expect(picked?.route).toEqual("/users/edit/123");
+  });
 
-    it("should return the route with least params", () => {
-        const routes = [
-            {
-                route: "/users/:action/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "/users/edit/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-        ];
+  it("should return the route with least params", () => {
+    const routes = [
+      {
+        route: "/users/:action/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "/users/edit/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+    ];
 
-        const picked = pickMatchedRoute(routes);
+    const picked = pickMatchedRoute(routes);
 
-        expect(picked?.route).toEqual("/users/edit/:id");
-    });
+    expect(picked?.route).toEqual("/users/edit/:id");
+  });
 
-    it("should return the latest parametrized route", () => {
-        const routes = [
-            {
-                route: "/users/page/:action/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "/users/page/list/:id/",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-        ];
+  it("should return the latest parametrized route", () => {
+    const routes = [
+      {
+        route: "/users/page/:action/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "/users/page/list/:id/",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+    ];
 
-        const picked = pickMatchedRoute(routes);
+    const picked = pickMatchedRoute(routes);
 
-        expect(picked?.route).toEqual("/users/page/list/:id/");
-    });
+    expect(picked?.route).toEqual("/users/page/list/:id/");
+  });
 
-    it("should return the latest parametrized route with single", () => {
-        const routes = [
-            {
-                route: "/users/:org/list/123",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-            {
-                route: "/users/refine/list/:id",
-                action: "edit" as const,
-                resource: { name: "users" },
-            },
-        ];
+  it("should return the latest parametrized route with single", () => {
+    const routes = [
+      {
+        route: "/users/:org/list/123",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+      {
+        route: "/users/refine/list/:id",
+        action: "edit" as const,
+        resource: { name: "users" },
+      },
+    ];
 
-        const picked = pickMatchedRoute(routes);
+    const picked = pickMatchedRoute(routes);
 
-        expect(picked?.route).toEqual("/users/refine/list/:id");
-    });
+    expect(picked?.route).toEqual("/users/refine/list/:id");
+  });
 });

package/src/definitions/helpers/router/__tests__/pick-route-params.ts

@@ -1,18 +1,18 @@
 import { pickRouteParams } from "../pick-route-params";
 
 describe("pickRouteParams", () => {
-    it("should extract route params from a path", () => {
-        expect(pickRouteParams("/users/:id/posts/:postId")).toEqual([
-            "id",
-            "postId",
-        ]);
-    });
+  it("should extract route params from a path", () => {
+    expect(pickRouteParams("/users/:id/posts/:postId")).toEqual([
+      "id",
+      "postId",
+    ]);
+  });
 
-    it("should return an empty array if no route params are given", () => {
-        expect(pickRouteParams("/users/list")).toEqual([]);
-    });
+  it("should return an empty array if no route params are given", () => {
+    expect(pickRouteParams("/users/list")).toEqual([]);
+  });
 
-    it("should extract route params from a path", () => {
-        expect(pickRouteParams("users/:id")).toEqual(["id"]);
-    });
+  it("should extract route params from a path", () => {
+    expect(pickRouteParams("users/:id")).toEqual(["id"]);
+  });
 });

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

@@ -1,26 +1,26 @@
 import { prepareRouteParams } from "../prepare-route-params";
 
 describe("prepareRouteParams", () => {
-    it("should return an empty object if no route params are given", () => {
-        expect(prepareRouteParams([])).toEqual({});
-    });
+  it("should return an empty object if no route params are given", () => {
+    expect(prepareRouteParams([])).toEqual({});
+  });
 
-    it("should return `id` property when params array contains `id`", () => {
-        expect(prepareRouteParams(["id"], { id: "1" })).toEqual({ id: "1" });
-    });
+  it("should return `id` property when params array contains `id`", () => {
+    expect(prepareRouteParams(["id"], { id: "1" })).toEqual({ id: "1" });
+  });
 
-    it("should prioritize meta over params", () => {
-        expect(prepareRouteParams(["id"], { id: "2" })).toEqual({
-            id: "2",
-        });
+  it("should prioritize meta over params", () => {
+    expect(prepareRouteParams(["id"], { id: "2" })).toEqual({
+      id: "2",
     });
+  });
 
-    it("should combine params and meta", () => {
-        expect(
-            prepareRouteParams(["id", "action"], {
-                ...{ id: "1" },
-                ...{ action: "2" },
-            }),
-        ).toEqual({ id: "1", action: "2" });
-    });
+  it("should combine params and meta", () => {
+    expect(
+      prepareRouteParams(["id", "action"], {
+        ...{ id: "1" },
+        ...{ action: "2" },
+      }),
+    ).toEqual({ id: "1", action: "2" });
+  });
 });