feat: util path deepTrimStartDir

Author: EqualMa

src/util/deep-map.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+interface DeepMapContext {
+  mapper: (v: any) => unknown;
+  processed: Map<unknown, unknown>;
+  cachedForTypes: Set<CacheForType>;
+}
+
+function deepMapImpl(value: unknown, ctx: DeepMapContext) {
+  if (ctx.processed.has(value)) return ctx.processed.get(value);
+
+  if (Array.isArray(value)) {
+    const res: unknown[] = [];
+    ctx.processed.set(value, res);
+    res.push(...value.map((v) => deepMapImpl(v, ctx)));
+    return res;
+  }
+
+  if (typeof value === "object" && value !== null) {
+    const res = {};
+    ctx.processed.set(value, res);
+
+    for (const k of Reflect.ownKeys(value)) {
+      const v: unknown = Reflect.get(value, k);
+      const r = deepMapImpl(v, ctx);
+      Reflect.set(res, k, r);
+    }
+
+    return res;
+  }
+
+  const res = ctx.mapper(value);
+
+  if (
+    (value === null && ctx.cachedForTypes.has("null")) ||
+    ctx.cachedForTypes.has(typeof value as never)
+  ) {
+    ctx.processed.set(value, res);
+  }
+
+  return res;
+}
+
+export type CacheForType =
+  | "string"
+  | "number"
+  | "symbol"
+  | "function"
+  | "undefined"
+  | "null"
+  | "bigint"
+  | "boolean";
+
+export interface DeepMapOptions {
+  cacheForTypes?: Iterable<CacheForType>;
+}
+
+export type AnyObjectOrArray = Record<string, unknown> | any[];
+
+export type DeepMappedByMapper<
+  T,
+  M extends (v: Exclude<T, AnyObjectOrArray>) => unknown,
+> = T extends AnyObjectOrArray
+  ? { [K in keyof T]: DeepMappedByMapper<T[K], M> }
+  : M extends (v: T) => infer R
+  ? R
+  : unknown;
+
+export type DeepMapped<TV, TVR> = TV extends AnyObjectOrArray
+  ? { [K in keyof TV]: DeepMapped<TV[K], TVR> }
+  : TVR;
+
+export function deepMap<TV, TVR>(
+  value: TV,
+  mapper: (
+    v: Exclude<
+      | TV
+      | (TV extends (infer TI)[]
+          ? TI
+          : TV extends Record<PropertyKey, infer TP>
+          ? TP
+          : never),
+      AnyObjectOrArray
+    >,
+  ) => TVR,
+  options?: DeepMapOptions,
+): DeepMapped<TV, TVR> {
+  return deepMapImpl(value, {
+    mapper,
+    cachedForTypes: new Set(options?.cacheForTypes),
+    processed: new Map(),
+  }) as never;
+}

src/util/path.test.ts

@@ -1,4 +1,4 @@
-import { trimStartDir } from "./path";
+import { deepTrimStartDir, trimStartDir } from "./path";
 
 test("trimStartDir", () => {
   const startDirVariants = [
@@ -35,3 +35,60 @@ test("trimStartDir", () => {
     }
   }
 });
+
+test("deepTrimStartDir", () => {
+  expect(deepTrimStartDir("./some-dir/some-file", "some-dir")).toBe(
+    "some-file",
+  );
+
+  expect(
+    deepTrimStartDir(
+      [
+        "./some-dir/some-file",
+        "dir/file2",
+        "./some-dir/file3",
+        { prop: "./some-dir/file4" },
+      ],
+      "some-dir",
+    ),
+  ).toStrictEqual(["some-file", "dir/file2", "file3", { prop: "file4" }]);
+
+  expect(
+    deepTrimStartDir(
+      { prop: "./some-dir/file", propNum: 1, propNull: null, propObj: {} },
+      "some-dir",
+    ),
+  ).toStrictEqual({
+    prop: "file",
+    propNum: 1,
+    propNull: null,
+    propObj: {},
+  });
+
+  const nested = {
+    num: 1,
+    path: "./some-dir/file",
+    obj: {
+      path: "./some-dir/dir2/file2",
+      propNull: null,
+      nested: undefined as unknown,
+    },
+  };
+
+  nested.obj.nested = nested;
+
+  const res = {
+    num: 1,
+    path: "file",
+    obj: {
+      path: "dir2/file2",
+      propNull: null,
+      nested: undefined as unknown,
+    },
+  };
+
+  res.obj.nested = res;
+
+  expect(deepTrimStartDir(nested, "some-dir")).toStrictEqual(res);
+  expect(res.obj.nested).toBe(res);
+});

src/util/path.ts

@@ -1,4 +1,5 @@
 import { posix as pp } from "path";
+import { deepMap } from "./deep-map";
 
 export function joinPath(...paths: string[]): string {
   return pp.join(...paths);
@@ -10,3 +11,29 @@ export function trimStartDir(p: string, startDir: string): string {
   if (res.startsWith("../")) return p;
   else return res || ".";
 }
+
+export type NestedPathValue =
+  | string
+  | NestedPathValue[]
+  | {
+      [K in PropertyKey]: unknown;
+    }
+  | undefined
+  | null
+  | number
+  | boolean
+  | bigint
+  | symbol
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | ((...args: any[]) => any);
+
+export function deepTrimStartDir<T extends NestedPathValue>(
+  p: T,
+  startDir: string,
+): T {
+  return deepMap<T, unknown>(
+    p,
+    (v: unknown) => (typeof v === "string" ? trimStartDir(v, startDir) : v),
+    { cacheForTypes: ["string", "null"] },
+  ) as never;
+}