Get rid of Lodash dependency

and use just Remeda and custom utils instead

package.json

@@ -17,14 +17,12 @@
   },
   "dependencies": {
     "cli-progress": "^3.8.2",
-    "lodash": "^4.17.20",
     "luxon": "^3.2.1",
     "remeda": "^1.3.0",
     "technicalindicators": "^3.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.2.5",
-    "@types/lodash": "^4.14.167",
     "@types/luxon": "^3.2.0",
     "@types/node": "^18.11.18",
     "husky": "^8.0.3",

src/backtest/backtest-order-execution.ts

@@ -1,4 +1,3 @@
-import { minBy } from "lodash";
 import {
   concat,
   drop,
@@ -7,6 +6,7 @@ import {
   isDefined,
   map,
   maxBy,
+  minBy,
   pipe,
 } from "remeda";
 import {

src/backtest/backtest-result.ts

@@ -1,8 +1,8 @@
-import { flatMap, max, min, sortBy, sumBy } from "lodash";
-import { map, pipe, values } from "remeda";
+import { flatMap, map, pipe, sortBy, sumBy, values } from "remeda";
 import { Candle, Range, Trade } from "../core/types";
 import { Timeframe, toTimestamp } from "../time";
 import { OverrideProps } from "../util/type-util";
+import { max, min } from "../util/util";
 import { BacktestAsyncArgs, BacktestState } from "./backtest";
 import { revertLastTransaction } from "./backtest-order-execution";
 import { updateAsset } from "./update-asset";
@@ -151,9 +151,11 @@ function revertUnclosedTrades(state: BacktestState) {
 }
 
 function getTradesInOrder(state: BacktestState) {
-  return sortBy(
-    flatMap(state.assets, (a) => a.trades),
-    (t) => t.entry.time
+  return pipe(
+    state.assets,
+    values,
+    flatMap((asset) => asset.trades),
+    sortBy((trade) => trade.entry.time)
   );
 }
 

src/backtest/backtest.ts

@@ -1,4 +1,3 @@
-import { tap } from "lodash/fp";
 import { first, last, pipe } from "remeda";
 import { CandleDataProvider, Persister } from "..";
 import {
@@ -10,7 +9,7 @@ import {
 } from "../core/types";
 import { Moment, Timeframe, toTimestamp } from "../time";
 import { Dictionary } from "../util/type-util";
-import { repeatUntil, repeatUntilAsync, then } from "../util/util";
+import { repeatUntil, repeatUntilAsync, tap, then } from "../util/util";
 import {
   BacktestPersistenceState,
   initBacktestPersistence,
@@ -28,12 +27,12 @@ import {
   createAsyncCandleProvider,
 } from "./candle-update-provider-async";
 import {
-  createSyncCandleProvider,
   SyncCandleUpdateProvider,
+  createSyncCandleProvider,
 } from "./candle-update-provider-sync";
 import { createCandleUpdates } from "./create-candle-updates";
 import { produceNextState } from "./produce-next-state";
-import { createProgressBar, ProgressHandler } from "./progress-handler";
+import { ProgressHandler, createProgressBar } from "./progress-handler";
 
 /**
  * Args used by both synchronous and asynchronous backtest.

src/backtest/candle-update-provider-async.ts

@@ -1,4 +1,3 @@
-import { dropRightWhile, dropWhile } from "lodash/fp";
 import { pipe, reverse } from "remeda";
 import { Range } from "../core/types";
 import {
@@ -7,7 +6,7 @@ import {
 } from "../data/candle-data-provider";
 import { Moment, Timeframe, timeframeToPeriod, toTimestamp } from "../time";
 import { Nullable } from "../util/type-util";
-import { then } from "../util/util";
+import { dropLastWhile, dropWhile, then } from "../util/util";
 import { BacktestAsyncArgs } from "./backtest";
 import { CandleUpdate, createCandleUpdates } from "./create-candle-updates";
 
@@ -67,7 +66,7 @@ function createDefaultAsyncCandleProvider(args: {
           (c: CandleUpdate) => c.time <= (previousCandleTime || -Infinity)
         )
       ),
-      then(dropRightWhile((c) => c.time > fullRange.to)),
+      then(dropLastWhile((c) => c.time > fullRange.to)),
       then(reverse()) // for perf, removing from end
     );
 

src/indicators/donchian-channel.ts

@@ -1,7 +1,7 @@
-import { maxBy, minBy } from "lodash";
+import { maxBy, minBy } from "remeda";
 import { Candle } from "../core/types";
 import { avg } from "../util/util";
-import { createIndicatorWithPeriod, IndicatorChannel } from "./indicator-util";
+import { IndicatorChannel, createIndicatorWithPeriod } from "./indicator-util";
 
 /**
  * Returns the value of a Donchian channel indicator.

src/indicators/indicator.ts

@@ -1,7 +1,6 @@
-import { takeRightWhile } from "lodash";
 import { AssetState, Candle } from "../core/types";
 import { Dictionary } from "../util/type-util";
-import { last } from "../util/util";
+import { last, takeLastWhile } from "../util/util";
 
 /*
 Note: While most of this project works with pure functions, the indicators
@@ -66,7 +65,7 @@ function createIndicator<RESULT>(initializer: () => (c: Candle) => RESULT) {
 
   return {
     update: ({ series, bufferSize }: IndicatorInputState): void => {
-      takeRightWhile(series, (c) => c.time > lastTimestamp).forEach((c) => {
+      takeLastWhile(series, (c) => c.time > lastTimestamp).forEach((c) => {
         const nextValue = nextValueGenerator(c);
         nextValue && result.push(nextValue);
         while (bufferSize !== undefined && result.length > bufferSize) {

src/stakers/common-staker.ts

@@ -1,5 +1,4 @@
-import { sumBy } from "lodash/fp";
-import { keys, map, mapValues, pipe, values } from "remeda";
+import { keys, map, mapValues, pipe, sumBy, values } from "remeda";
 import { AssetMap, AssetState, FullTradeState } from "../core/types";
 import { SizelessOrder, Staker, StrategyUpdate } from "../high-level-api/types";
 import { Dictionary, OverrideProps } from "../util/type-util";

src/strategies/higher-order/auto-optimizer.ts

@@ -1,4 +1,4 @@
-import { maxBy } from "lodash";
+import { maxBy } from "remeda";
 import {
   allInStaker,
   AssetState,

src/time/to-start-of.ts

@@ -1,4 +1,4 @@
-import { dropRightWhile } from "lodash";
+import { dropLastWhile } from "../util/util";
 import { Moment, toDateTime, toTimestamp } from "./moment";
 
 const TIME_PROPS = ["year", "month", "day", "hour", "minute"] as const;
@@ -16,7 +16,7 @@ export function toStartOf(
 ): number {
   const dateTime = toDateTime(time);
 
-  const propsToCopy = dropRightWhile(TIME_PROPS, (p) => p !== unit);
+  const propsToCopy = dropLastWhile(TIME_PROPS, (p) => p !== unit);
 
   const timeObject: Record<(typeof TIME_PROPS)[number], number> =
     TIME_PROPS.reduce(

src/util/util.ts

@@ -1,10 +1,14 @@
-import _ from "lodash";
 import {
-  fromPairs as remedaFromPairs,
   identity,
   isArray,
   isNumber,
+  maxBy,
+  minBy,
+  purry,
+  fromPairs as remedaFromPairs,
+  pickBy as remedaPickBy,
   sort,
+  sumBy,
 } from "remeda";
 import { Candle, CandleSeries, Order } from "../core/types";
 import { SizelessOrder } from "../high-level-api/types";
@@ -31,9 +35,9 @@ export function last<T>(array: Array<T>) {
 export function avg(values: number[]): number {
   return sum(values) / values.length;
 }
-export function sum(values: number[]): number {
-  return values.reduce((sum, value) => sum + value, 0);
-}
+export const sum = sumBy<number>(identity);
+export const min = minBy<number>(identity);
+export const max = maxBy<number>(identity);
 
 export function getAverageCandleSize(
   series: CandleSeries,
@@ -134,22 +138,12 @@ export const fromPairs = <T>(pairs: [string, T][]) => remedaFromPairs(pairs);
 /**
  * Filters object entries by the given predicate.
  *
- * Lodash's pickBy curried and with better typing.
+ * Remeda's pickBy with looser typing.
  */
 export const pickBy =
   <T>(predicate: (value: T, key: string) => boolean) =>
   (obj: Dictionary<T>): Dictionary<T> =>
-    _.pickBy(obj, predicate);
-
-/**
- * Maps object values by the given function.
- *
- * Lodash's mapValues curried and with better typing.
- */
-export const mapValues =
-  <T, R>(mapper: (value: T, key: string) => R) =>
-  (obj: Dictionary<T>): Dictionary<R> =>
-    _.mapValues(obj, mapper);
+    remedaPickBy(obj, predicate);
 
 /**
  * Enables using Promise.then in pipe without arrow functions.
@@ -199,3 +193,79 @@ export const repeatUntilAsync =
     }
     return value;
   };
+
+export function tap<T>(value: T, fn: (value: T) => void): T;
+export function tap<T>(fn: (value: T) => void): (value: T) => T;
+export function tap() {
+  return purry(_tap, arguments);
+}
+function _tap<T>(value: T, fn: (value: T) => void): T {
+  fn(value);
+  return value;
+}
+
+export function takeLastWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): Array<T>;
+export function takeLastWhile<T>(
+  fn: (item: T) => boolean
+): (array: ReadonlyArray<T>) => Array<T>;
+export function takeLastWhile() {
+  return purry(_takeLastWhile, arguments);
+}
+export function _takeLastWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): ReadonlyArray<T> {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (!fn(array[i])) {
+      return array.slice(i + 1);
+    }
+  }
+  return array;
+}
+
+export function dropWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): Array<T>;
+export function dropWhile<T>(
+  fn: (item: T) => boolean
+): (array: ReadonlyArray<T>) => Array<T>;
+export function dropWhile() {
+  return purry(_dropWhile, arguments);
+}
+export function _dropWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): ReadonlyArray<T> {
+  for (let i = 0; i < array.length; i++) {
+    if (!fn(array[i])) {
+      return array.slice(i);
+    }
+  }
+  return [];
+}
+
+export function dropLastWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): Array<T>;
+export function dropLastWhile<T>(
+  fn: (item: T) => boolean
+): (array: ReadonlyArray<T>) => Array<T>;
+export function dropLastWhile() {
+  return purry(_dropLastWhile, arguments);
+}
+export function _dropLastWhile<T>(
+  array: ReadonlyArray<T>,
+  fn: (item: T) => boolean
+): ReadonlyArray<T> {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (!fn(array[i])) {
+      return array.slice(0, i + 1);
+    }
+  }
+  return [];
+}

test/backtest-add-candles.test.ts

@@ -1,4 +1,4 @@
-import { last } from "lodash/fp";
+import { last } from "remeda";
 import { backtestSync } from "../src";
 import { Candle, FullTradingStrategy, SeriesMap } from "../src/core/types";