@vlandoss/run-run 0.0.14-git-40ae44d.0 → 0.0.14-git-cf575e8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/run-run",
-  "version": "0.0.14-git-40ae44d.0",
+  "version": "0.0.14-git-cf575e8.0",
   "description": "The CLI toolbox to fullstack common scripts in Variable Land",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/run-run#readme",
   "bugs": {
@@ -19,28 +19,29 @@
   "bin": {
     "rr": "./bin.ts",
     "run-run": "./bin.ts",
-    "biome": "./tools/biome"
+    "biome": "./tools/biome",
+    "oxfmt": "./tools/oxfmt",
+    "oxlint": "./tools/oxlint"
   },
   "files": [
-    "bin",
+    "bin.ts",
     "src",
     "tools",
-    "plopfiles",
     "tsconfig.json"
   ],
   "dependencies": {
     "@biomejs/biome": "2.1.4",
-    "c12": "4.0.0-beta.3",
     "commander": "13.1.0",
     "glob": "^11.0.2",
     "is-ci": "4.1.0",
+    "lilconfig": "^3.1.3",
     "memoize": "^10.2.0",
     "oxfmt": "^0.35.0",
     "oxlint": "^1.50.0",
     "oxlint-tsgolint": "^0.15.0",
     "rimraf": "6.0.1",
     "typescript": "5.8.2",
-    "@vlandoss/clibuddy": "0.0.5",
+    "@vlandoss/clibuddy": "0.0.6-git-cf575e8.0",
     "@vlandoss/loggy": "0.0.5"
   },
   "publishConfig": {

package/src/program/commands/check.ts

@@ -10,20 +10,16 @@ export function createCheckCommand(ctx: Context) {
     .option("-f, --fix", "try to fix issues automatically")
     .option("--fix-staged", "try to fix staged files only")
     .action(async function checkAction(options) {
-      const { $ } = new BiomeService(ctx.shell);
-      const toolCmd = (cmd = "check") => `biome ${cmd} --colors=force`;
+      const biome = new BiomeService(ctx.shell);
+      const toolCmd = (cmd = "check") => `${cmd} --colors=force`;
 
       if (options.fix) {
-        await $`${toolCmd()} --fix`;
-        return;
+        await biome.exec(`${toolCmd()} --fix`);
+      } else if (options.fixStaged) {
+        await biome.exec(`${toolCmd()} --no-errors-on-unmatched --fix --staged`);
+      } else {
+        await biome.exec(`${toolCmd(isCI ? "ci" : "check")}`);
       }
-
-      if (options.fixStaged) {
-        await $`${toolCmd()} --no-errors-on-unmatched --fix --staged`;
-        return;
-      }
-
-      await $`${toolCmd(isCI ? "ci" : "check")}`;
     })
     .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to check the code.");
 }

package/src/program/commands/config.ts

@@ -1,3 +1,4 @@
+import { colors } from "@vlandoss/clibuddy";
 import { createCommand } from "commander";
 import type { Context } from "#/services/ctx";
 
@@ -5,7 +6,10 @@ export function createConfigCommand(ctx: Context) {
   return createCommand("config")
     .alias("cfg")
     .description("display the current config 🛠️")
-    .action(function configAction() {
-      console.log(ctx.config);
+    .action(async function configAction() {
+      const { config, meta } = ctx.config;
+      console.log(colors.muted("Config:"));
+      console.log(config);
+      console.log(colors.muted(`Loaded from ${meta.filepath ? colors.link(meta.filepath) : "n/a"}`));
     });
 }

package/src/program/commands/format.ts

@@ -2,52 +2,33 @@ import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
 import { OxfmtService } from "#/services/oxfmt";
+import type { Formatter } from "#/types/tool";
 
 type ActionOptions = {
   check?: boolean;
   fix?: boolean;
 };
 
-export function createFormatCommand(ctx: Context) {
-  const fmtCommand = createCommand("fmt")
-    .alias("format")
-    .description("format the code 🎨")
-    .option("-c, --check", "check if the code is formatted", true)
-    .option("-f, --fix", "format all the code");
+function getToolService(ctx: Context): Formatter {
+  const { config } = ctx.config;
 
-  if (ctx.config.future?.oxc) {
-    fmtCommand
-      .action(async function formatAction(options: ActionOptions) {
-        const { $ } = new OxfmtService(ctx.shell);
-        const toolCmd = "oxfmt --no-error-on-unmatched-pattern";
-
-        if (options.fix) {
-          await $`${toolCmd} --fix`;
-          return;
-        }
-
-        if (options.check) {
-          await $`${toolCmd} --check`;
-        }
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxfmt CLI to format the code.");
-  } else {
-    fmtCommand
-      .action(async function formatAction(options: ActionOptions) {
-        const { $ } = new BiomeService(ctx.shell);
-        const toolCmd = "biome format --no-errors-on-unmatched --colors=force";
+  if (config.future?.oxc) {
+    return new OxfmtService(ctx.shell);
+  }
 
-        if (options.fix) {
-          await $`${toolCmd} --fix`;
-          return;
-        }
+  return new BiomeService(ctx.shell);
+}
 
-        if (options.check) {
-          await $`${toolCmd}`;
-        }
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to format the code.");
-  }
+export function createFormatCommand(ctx: Context) {
+  const toolService = getToolService(ctx);
 
-  return fmtCommand;
+  return createCommand("fmt")
+    .alias("format")
+    .description("format the code 🎨")
+    .option("-c, --check", "check if the code is formatted", true)
+    .option("-f, --fix", "format all the code")
+    .action(async function formatAction(options: ActionOptions) {
+      await toolService.format(options);
+    })
+    .addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.bin} CLI to format the code.`);
 }

package/src/program/commands/lint.ts

@@ -2,51 +2,32 @@ import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
 import { OxlintService } from "#/services/oxlint";
+import type { Linter } from "#/types/tool";
 
 type ActionOptions = {
   check?: boolean;
   fix?: boolean;
 };
 
-export function createLintCommand(ctx: Context) {
-  const lintCommand = createCommand("lint")
-    .description("lint the code 🧹")
-    .option("-c, --check", "check if the code is valid", true)
-    .option("-f, --fix", "try to fix all the code");
+function getToolService(ctx: Context): Linter {
+  const { config } = ctx.config;
 
-  if (ctx.config.future?.oxc) {
-    lintCommand
-      .action(async function lintAction(options: ActionOptions) {
-        const { $ } = new OxlintService(ctx.shell);
-        const toolCmd = "oxlint --report-unused-disable-directives";
-
-        if (options.fix) {
-          await $`${toolCmd} --fix`;
-          return;
-        }
-
-        if (options.check) {
-          await $`${toolCmd} --check`;
-        }
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxlint CLI to lint the code.");
-  } else {
-    lintCommand
-      .action(async function lintAction(options: ActionOptions) {
-        const { $ } = new BiomeService(ctx.shell);
-        const toolCmd = "biome check --colors=force --formatter-enabled=false";
+  if (config.future?.oxc) {
+    return new OxlintService(ctx.shell);
+  }
 
-        if (options.fix) {
-          await $`${toolCmd} --fix --unsafe`;
-          return;
-        }
+  return new BiomeService(ctx.shell);
+}
 
-        if (options.check) {
-          await $`${toolCmd}`;
-        }
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to lint the code.");
-  }
+export function createLintCommand(ctx: Context) {
+  const toolService = getToolService(ctx);
 
-  return lintCommand;
+  return createCommand("lint")
+    .description("lint the code 🧹")
+    .option("-c, --check", "check if the code is valid", true)
+    .option("-f, --fix", "try to fix all the code")
+    .action(async function lintAction(options: ActionOptions) {
+      await toolService.lint(options);
+    })
+    .addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.bin} CLI to lint the code.`);
 }

package/src/program/commands/tools.ts

@@ -1,41 +1,45 @@
+import type { ShellService } from "@vlandoss/clibuddy";
 import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
 import { OxfmtService } from "#/services/oxfmt";
 import { OxlintService } from "#/services/oxlint";
+import type { ToolService } from "#/services/tool";
 
 type ActionParams = {
   args: string[];
 };
 
-function createToolCommand(toolBin: string) {
-  // biome-ignore format: I prefer multi-line here
-  return createCommand(toolBin)
+function getToolService(bin: string, shell: ShellService): ToolService {
+  switch (bin) {
+    case "biome":
+      return new BiomeService(shell);
+    case "oxfmt":
+      return new OxfmtService(shell);
+    case "oxlint":
+      return new OxlintService(shell);
+    default:
+      throw new Error(`Unknown tool: ${bin}`);
+  }
+}
+
+function createToolCommand(bin: string, shell: ShellService) {
+  const tool = getToolService(bin, shell);
+
+  return createCommand(tool.bin)
     .helpCommand(false)
     .helpOption(false)
     .allowExcessArguments(true)
-    .allowUnknownOption(true);
+    .allowUnknownOption(true)
+    .action(async (_: unknown, { args }: ActionParams) => {
+      await tool.exec(args);
+    });
 }
 
 export function createToolsCommand(ctx: Context) {
   return createCommand("tools")
     .description("expose the internal tools 🛠️")
-    .addCommand(
-      createToolCommand("biome").action((_: unknown, { args }: ActionParams) => {
-        const biomeService = new BiomeService(ctx.shell);
-        biomeService.execute(args);
-      }),
-    )
-    .addCommand(
-      createToolCommand("oxfmt").action((_: unknown, { args }: ActionParams) => {
-        const oxfmtService = new OxfmtService(ctx.shell);
-        oxfmtService.execute(args);
-      }),
-    )
-    .addCommand(
-      createToolCommand("oxlint").action((_: unknown, { args }: ActionParams) => {
-        const oxlintService = new OxlintService(ctx.shell);
-        oxlintService.execute(args);
-      }),
-    );
+    .addCommand(createToolCommand("biome", ctx.shell))
+    .addCommand(createToolCommand("oxfmt", ctx.shell))
+    .addCommand(createToolCommand("oxlint", ctx.shell));
 }

package/src/program/commands/typecheck.ts

@@ -1,4 +1,4 @@
-import { cwd } from "@vlandoss/clibuddy";
+import { cwd, type ShellService } from "@vlandoss/clibuddy";
 import type { AnyLogger } from "@vlandoss/loggy";
 import { createCommand } from "commander";
 import type { Context } from "#/services/ctx";
@@ -9,86 +9,96 @@ type TypecheckAtOptions = {
   dir: string;
   scripts: Record<string, string | undefined> | undefined;
   log: AnyLogger;
+  shell: ShellService;
+  run: (shell: ShellService) => Promise<void>;
 };
 
-export function createTypecheckCommand(ctx: Context) {
-  const typecheckCommand = createCommand("tsc").alias("typecheck").description("check if TypeScript code is well typed 🎨");
+const getPreScript = (scripts: Record<string, string | undefined> | undefined) => scripts?.pretsc ?? scripts?.pretypecheck;
 
-  if (ctx.config.future?.oxc) {
-    typecheckCommand
-      .action(async function typecheckAction() {
-        const { $ } = new OxlintService(ctx.shell);
-        await $`oxlint --type-aware --type-check --report-unused-disable-directives`;
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxlint CLI to check the code.");
-  } else {
-    typecheckCommand
-      .action(async function typecheckAction() {
-        const { appPkg, shell } = ctx;
+async function typecheckAt({ dir, scripts, log, shell, run }: TypecheckAtOptions) {
+  const shellAt = cwd === dir ? shell : shell.at(dir);
 
-        const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
+  try {
+    const preScript = getPreScript(scripts);
+    if (preScript) {
+      log.start(`Running pre-script: ${preScript}`);
+      await shellAt.$`${preScript}`;
+      log.success("Pre-script completed");
+    }
 
-        const getPreScript = (scripts: Record<string, string | undefined> | undefined) =>
-          scripts?.pretsc ?? scripts?.pretypecheck;
+    log.start("Type checking started");
+    await run(shellAt);
+    log.success("Typecheck completed");
+  } catch (error) {
+    log.error("Typecheck failed");
+    throw error;
+  }
+}
 
-        async function typecheckAt({ dir, scripts, log }: TypecheckAtOptions) {
-          const shellAt = cwd === dir ? shell : shell.at(dir);
+export function createTypecheckCommand(ctx: Context) {
+  const {
+    appPkg,
+    shell,
+    config: { config },
+  } = ctx;
 
-          try {
-            const preScript = getPreScript(scripts);
-            if (preScript) {
-              log.start(`Running pre-script: ${preScript}`);
-              await shellAt.$`${preScript}`;
-              log.success("Pre-script completed");
-            }
+  return createCommand("tsc")
+    .alias("typecheck")
+    .description("check if TypeScript code is well typed 🎨")
+    .addHelpText(
+      "afterAll",
+      `\nUnder the hood, this command uses the ${config.future?.oxc ? "oxlint" : "TypeScript"} CLI to check the code.`,
+    )
+    .action(async function typecheckAction() {
+      const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
 
-            log.start("Type checking started");
-            await shellAt.$`tsc --noEmit`;
-            log.success("Typecheck completed");
-          } catch (error) {
-            log.error("Typecheck failed");
-            throw error;
-          }
+      const runTypecheck = async (shell: ShellService) => {
+        if (config.future?.oxc) {
+          const oxlint = new OxlintService(shell);
+          await oxlint.exec(`--type-aware --type-check --report-unused-disable-directives`);
+        } else {
+          await shell.$`tsc --noEmit`;
         }
+      };
 
-        if (!appPkg.isMonorepo()) {
-          if (!isTsProject(appPkg.dirPath)) {
-            logger.info("No tsconfig.json found, skipping typecheck");
-            return;
-          }
-
-          await typecheckAt({
-            dir: appPkg.dirPath,
-            scripts: appPkg.packageJson.scripts,
-            log: logger,
-          });
-
+      if (!appPkg.isMonorepo()) {
+        if (!isTsProject(appPkg.dirPath)) {
+          logger.info("No tsconfig.json found, skipping typecheck");
           return;
         }
 
-        const projects = await appPkg.getWorkspaceProjects();
-        const tsProjects = projects.filter((project) => isTsProject(project.rootDir));
+        await typecheckAt({
+          shell,
+          run: runTypecheck,
+          dir: appPkg.dirPath,
+          scripts: appPkg.packageJson.scripts,
+          log: logger,
+        });
 
-        if (!tsProjects.length) {
-          logger.warn("No TypeScript projects found in the monorepo, skipping typecheck");
-          return;
-        }
+        return;
+      }
 
-        await Promise.all(
-          tsProjects.map((p) =>
-            typecheckAt({
-              dir: p.rootDir,
-              scripts: p.manifest.scripts,
-              log: logger.child({
-                tag: p.manifest.name,
-                namespace: "typecheck",
-              }),
-            }),
-          ),
-        );
-      })
-      .addHelpText("afterAll", "\nUnder the hood, this command uses the TypeScript CLI to check the code.");
-  }
+      const projects = await appPkg.getWorkspaceProjects();
+      const tsProjects = projects.filter((project) => isTsProject(project.rootDir));
+
+      if (!tsProjects.length) {
+        logger.warn("No TypeScript projects found in the monorepo, skipping typecheck");
+        return;
+      }
 
-  return typecheckCommand;
+      await Promise.all(
+        tsProjects.map((p) =>
+          typecheckAt({
+            shell,
+            run: runTypecheck,
+            dir: p.rootDir,
+            scripts: p.manifest.scripts,
+            log: logger.child({
+              tag: p.manifest.name,
+              namespace: "typecheck",
+            }),
+          }),
+        ),
+      );
+    });
 }

package/src/services/biome.ts

@@ -1,12 +1,33 @@
 import type { ShellService } from "@vlandoss/clibuddy";
+import type { FormatOptions, Formatter, Linter, LintOptions } from "#/types/tool";
 import { ToolService } from "./tool";
 
-export class BiomeService extends ToolService {
+export class BiomeService extends ToolService implements Formatter, Linter {
   constructor(shellService: ShellService) {
-    super({ cmd: "biome", shellService });
+    super({ bin: "biome", shellService });
   }
 
   getBinDir() {
     return require.resolve("@biomejs/biome/bin/biome");
   }
+
+  async format(options: FormatOptions) {
+    const commonOptions = "format --no-errors-on-unmatched --colors=force";
+
+    if (options.fix) {
+      await this.exec(`${commonOptions} --fix`);
+    } else if (options.check) {
+      await this.exec(`${commonOptions}`);
+    }
+  }
+
+  async lint(options: LintOptions) {
+    const commonOptions = "check --colors=force --formatter-enabled=false";
+
+    if (options.fix) {
+      await this.exec(`${commonOptions} --fix --unsafe`);
+    } else if (options.check) {
+      await this.exec(`${commonOptions}`);
+    }
+  }
 }

package/src/services/config.ts

@@ -1,5 +1,6 @@
-import { loadConfig } from "c12";
-import type { UserConfig } from "#/types/config";
+import os from "node:os";
+import { type AsyncSearcher, lilconfig } from "lilconfig";
+import type { ExportedConfig, UserConfig } from "#/types/config";
 import { logger } from "./logger";
 
 const DEFAULT_CONFIG: UserConfig = {
@@ -9,19 +10,46 @@ const DEFAULT_CONFIG: UserConfig = {
 };
 
 export class ConfigService {
-  async load(cwd?: string) {
-    const debug = logger.subdebug("load-config");
+  #searcher: AsyncSearcher;
 
-    const result = await loadConfig<UserConfig>({
-      cwd,
-      name: "run-run",
-      defaultConfig: DEFAULT_CONFIG,
+  constructor() {
+    this.#searcher = lilconfig("run-run", {
+      searchPlaces: ["run-run.config.ts"],
+      cache: true,
+      stopDir: os.homedir(),
+      loaders: {
+        ".ts": (filepath: string) => import(filepath).then((mod) => mod.default),
+      },
     });
+  }
+
+  async load(): Promise<ExportedConfig> {
+    const debug = logger.subdebug("load-config");
+
+    const searchResult = await this.#searcher.search();
+
+    if (!searchResult || searchResult?.isEmpty) {
+      debug("loaded default config: %O", DEFAULT_CONFIG);
+      return {
+        config: DEFAULT_CONFIG,
+        meta: {
+          isDefault: true,
+          filepath: undefined,
+        },
+      };
+    }
+
+    const config = searchResult.config as UserConfig;
 
-    debug("loaded config: %O", result.config);
-    debug("config cwd: %s", result.cwd);
-    debug("config file: %s", result.configFile);
+    debug("loaded config: %O", config);
+    debug("config file: %s", searchResult.filepath);
 
-    return result.config;
+    return {
+      config,
+      meta: {
+        isDefault: false,
+        filepath: searchResult.filepath,
+      },
+    };
   }
 }

package/src/services/ctx.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { createPkgService, createShellService, cwd, type PkgService, type ShellService } from "@vlandoss/clibuddy";
-import type { UserConfig } from "#/types/config";
+import type { ExportedConfig } from "#/types/config";
 import { ConfigService } from "./config";
 import { logger } from "./logger";
 
@@ -8,7 +8,7 @@ export type Context = {
   binPkg: PkgService;
   appPkg: PkgService;
   shell: ShellService;
-  config: UserConfig;
+  config: ExportedConfig;
 };
 
 export async function createContext(binDir: string): Promise<Context> {

package/src/services/oxfmt.ts

@@ -1,12 +1,23 @@
 import type { ShellService } from "@vlandoss/clibuddy";
+import type { FormatOptions, Formatter } from "#/types/tool";
 import { ToolService } from "./tool";
 
-export class OxfmtService extends ToolService {
+export class OxfmtService extends ToolService implements Formatter {
   constructor(shellService: ShellService) {
-    super({ cmd: "oxfmt", shellService });
+    super({ bin: "oxfmt", shellService });
   }
 
   getBinDir() {
     return require.resolve("oxfmt/bin/oxfmt");
   }
+
+  async format(options: FormatOptions) {
+    const commonOptions = "--no-error-on-unmatched-pattern";
+
+    if (options.fix) {
+      await this.exec(`${commonOptions} --fix`);
+    } else if (options.check) {
+      await this.exec(`${commonOptions} --check`);
+    }
+  }
 }

package/src/services/oxlint.ts

@@ -1,12 +1,23 @@
 import type { ShellService } from "@vlandoss/clibuddy";
+import type { Linter, LintOptions } from "#/types/tool";
 import { ToolService } from "./tool";
 
-export class OxlintService extends ToolService {
+export class OxlintService extends ToolService implements Linter {
   constructor(shellService: ShellService) {
-    super({ cmd: "oxlint", shellService });
+    super({ bin: "oxlint", shellService });
   }
 
   getBinDir() {
     return require.resolve("oxlint/bin/oxlint");
   }
+
+  async lint(options: LintOptions) {
+    const commonOptions = "--report-unused-disable-directives";
+
+    if (options.fix) {
+      await this.exec(`${commonOptions} --fix`);
+    } else if (options.check) {
+      await this.exec(`${commonOptions} --check`);
+    }
+  }
 }

package/src/services/tool.ts

@@ -1,29 +1,40 @@
-import type { ShellService } from "@vlandoss/clibuddy";
+import type { Shell, ShellService } from "@vlandoss/clibuddy";
+import memoize from "memoize";
 import { gracefullBinDir } from "#/utils/gracefullBinDir";
 
 type CreateOptions = {
-  cmd: string;
+  bin: string;
   shellService: ShellService;
 };
 
 export abstract class ToolService {
   #shellService: ShellService;
-  #cmd: string;
+  #bin: string;
 
-  constructor({ cmd, shellService }: CreateOptions) {
-    this.#cmd = cmd;
+  constructor({ bin: cmd, shellService }: CreateOptions) {
+    this.#bin = cmd;
     this.#shellService = shellService;
   }
 
   abstract getBinDir(): string;
 
-  get $() {
+  exec(args: string | string[]) {
+    const $ = this.#shell();
+    return this.#run($, args);
+  }
+
+  #shell = memoize((cwd?: string) => {
     return this.#shellService.child({
+      cwd,
       preferLocal: gracefullBinDir(() => this.getBinDir()),
     }).$;
+  });
+
+  #run(shell: Shell, args: string | string[]) {
+    return shell`${this.#bin} ${typeof args === "string" ? args : args.join(" ")}`;
   }
 
-  async execute(args: string[]): Promise<void> {
-    this.$`${this.#cmd} ${args.join(" ")}`;
+  get bin() {
+    return this.#bin;
   }
 }

package/src/types/config.ts

@@ -3,3 +3,11 @@ export type UserConfig = {
     oxc?: boolean;
   };
 };
+
+export type ExportedConfig = {
+  config: UserConfig;
+  meta: {
+    isDefault: boolean;
+    filepath?: string;
+  };
+};

package/src/types/tool.ts

@@ -0,0 +1,19 @@
+export type FormatOptions = {
+  check?: boolean;
+  fix?: boolean;
+};
+
+export type LintOptions = {
+  check?: boolean;
+  fix?: boolean;
+};
+
+export type Formatter = {
+  bin: string;
+  format(options: FormatOptions): Promise<void>;
+};
+
+export type Linter = {
+  bin: string;
+  lint(options: LintOptions): Promise<void>;
+};

package/src/utils/__tests__/get.test.ts

@@ -1,22 +0,0 @@
-import { expect, it } from "bun:test";
-import { get } from "../get";
-
-it("should get the value when the key is found", () => {
-  const obj = { a: 1 };
-  expect(get(obj, "a")).toBe(1);
-});
-
-it("should get the value when the nested key is found", () => {
-  const obj = { a: { b: { c: 1 } } };
-  expect(get(obj, "a.b.c")).toBe(1);
-});
-
-it("should get undefined when the key is not found", () => {
-  const obj = { a: 1 };
-  expect(get(obj, "b")).toBeUndefined();
-});
-
-it("should get undefined when the nested key is not found", () => {
-  const obj = { a: { b: { c: 1 } } };
-  expect(get(obj, "a.b.d")).toBeUndefined();
-});

package/src/utils/get.ts

@@ -1,30 +0,0 @@
-export function get(obj: unknown, key: string) {
-  if (typeof obj !== "object" || obj === null) {
-    return undefined;
-  }
-
-  if (typeof key !== "string") {
-    throw new Error("Key must be a string");
-  }
-
-  const parts = key.split(".");
-
-  let value = {
-    ...obj,
-  };
-
-  for (let i = 0; i < parts.length; i++) {
-    const key = parts[i] as string;
-
-    // @ts-expect-error value is type to {}
-    const subValue = value[key];
-
-    if (!subValue) {
-      return undefined;
-    }
-
-    value = subValue;
-  }
-
-  return value;
-}