Merge pull request #28 from bartstc/chore/remove-lodash

chore: replace lodash with ramda

Author: bartstc

eslint.config.mjs

@@ -149,27 +149,12 @@ export default config(
       "no-restricted-imports": [
         "error",
         {
-          patterns: ["lodash/**", "lodash/fp/**", "react-router"],
+          patterns: ["react-router"],
           paths: [
-            {
-              message: `Please use import { method } from "lodash-es" instead.`,
-              name: "lodash",
-            },
-            {
-              importNames: ["chain"],
-              message:
-                "Avoid using chain since it is non tree-shakable. Try out flow instead.",
-              name: "lodash-es",
-            },
             {
               importNames: ["default"],
-              message: `Instead of default import, please use import { method } from "lodash-es" instead.`,
-              name: "lodash-es",
-            },
-            {
-              message:
-                "Avoid using chain since it is non tree-shakable. Try out flow instead.",
-              name: "lodash-es/chain",
+              message: `Instead of default import, please use import { method } from "ramda" instead.`,
+              name: "ramda",
             },
           ],
         },

package.json

@@ -30,8 +30,8 @@
     "i18next-http-backend": "3.0.2",
     "i18next-localstorage-backend": "4.2.0",
     "ky": "0.33.3",
-    "lodash-es": "4.17.21",
     "query-string": "8.2.0",
+    "ramda": "^0.31.3",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "react-error-boundary": "3.1.4",
@@ -49,7 +49,7 @@
     "@storybook/test-runner": "0.23.0",
     "@testing-library/jest-dom": "6.6.3",
     "@testing-library/react": "16.0.0",
-    "@types/lodash-es": "4.17.12",
+    "@types/ramda": "^0.30.2",
     "@types/react": "19.1.8",
     "@types/react-dom": "19.1.6",
     "@types/testing-library__jest-dom": "5.14.9",

pnpm-lock.yaml

@@ -1,4 +1,4 @@
-import { omit } from "lodash-es";
+import { omit } from "ramda";
 
 import type { IUser } from "@/features/auth/types/IUser";
 import { httpService } from "@/lib/http";
@@ -9,5 +9,5 @@ export const getUser = () => {
   // mocking current user and its cartId by passing id=1
   return httpService
     .get<IUserDto>("users/1")
-    .then((res) => ({ ...(omit(res, "password") as IUser), cartId: 1 }));
+    .then((res) => ({ ...(omit(["password"], res) as IUser), cartId: 1 }));
 };

src/features/auth/infrastructure/getUser.ts

@@ -1,6 +1,6 @@
-import { isEmpty } from "lodash-es";
 import queryString from "query-string";
 
+import { isEmpty } from "@/lib/isEmpty";
 import type { IQueryParams } from "@/types/IQueryParams";
 
 export const buildUrl = <Params = IQueryParams>(

src/lib/buildUrl.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+import type { ComponentClass, ComponentType } from "react";
+
+/**
+ * Enhances a React component by composing it with higher-order components.
+ *
+ * @param component - The base component to enhance.
+ * @param higherOrderComponents - An array of HoCs to apply to the base component.
+ * @returns A new component that includes the specified enhancements.
+ */
+
+type ComponentEnhancer<TInnerProps, TOutterProps> = (
+  component: ComponentType<TInnerProps>
+) => ComponentClass<TOutterProps>;
+
+export function compose<TInnerProps, TOutterProps>(
+  ...higherOrderComponents: Function[]
+): ComponentEnhancer<TInnerProps, TOutterProps> {
+  return higherOrderComponents.reduce(
+    (composedComponent, nextEnhancer) =>
+      (...componentProps: unknown[]) =>
+        composedComponent(nextEnhancer(...componentProps)),
+    (arg: unknown) => arg
+  ) as ComponentEnhancer<TInnerProps, TOutterProps>;
+}

src/lib/compose.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+
+import { get } from "./get";
+
+describe("get", () => {
+  it("should return the value at the given path", () => {
+    const obj = { a: { b: { c: 1 } } };
+    expect(get(obj, "a.b.c")).toBe(1);
+  });
+
+  it("should return undefined if the path does not exist", () => {
+    const obj = { a: { b: { c: 1 } } };
+    expect(get(obj, "a.b.d")).toBeUndefined();
+  });
+
+  it("should handle array indices", () => {
+    const obj = { a: { b: [1, 2, 3] } };
+    expect(get(obj, "a.b.1")).toBe(2);
+  });
+
+  it("should handle complex paths", () => {
+    const obj = { a: { b: [{ c: 1 }, { c: 2 }, { c: 3 }] } };
+    expect(get(obj, "a.b.1.c")).toBe(2);
+  });
+});

src/lib/get.test.ts

@@ -0,0 +1,10 @@
+import { lensPath, view, split } from "ramda";
+
+export const get = <TResult, TObject, TPath extends string>(
+  obj: TObject,
+  path: TPath
+): TResult => {
+  const pathArray = split(/[[\].]/, path);
+  const lens = lensPath(pathArray);
+  return view(lens, obj) as TResult;
+};

src/lib/get.ts

@@ -0,0 +1,3 @@
+import { either, isNil, isEmpty as _isEmpty } from "ramda";
+
+export const isEmpty = either(isNil, _isEmpty);