feat: refactor project structure and enhance utility functions

Author: GoodbyeNJN

src/common/error.ts

@@ -1,77 +1,5 @@
-import { err, ok } from "@/result";
+export { NonZeroExitError } from "../shared/error";
+export { Process, exec, exec as x, exec as $ } from "./process";
 
-import { NonZeroExitError } from "../error";
-import { BaseProcess } from "../process";
-import { readStreamLines, readStreams } from "../stream";
-
-import type { Exec, ProcessInstance, ProcessOptions } from "./types";
-import type { ExecParams, Output } from "../types";
-import type { Result } from "@/result";
-
-export class Process
-    extends BaseProcess<Result<Output, Error>, Result<string, Error>>
-    implements ProcessInstance
-{
-    declare exec: Exec;
-    declare pipe: Exec;
-
-    declare protected options: Partial<ProcessOptions>;
-
-    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-    constructor(options?: Partial<ProcessOptions>) {
-        super(options);
-    }
-
-    override async *[Symbol.asyncIterator](): AsyncIterator<Result<string, Error>> {
-        const p = this.process;
-        if (!p) return err(new Error("No process was started"));
-
-        for await (const line of readStreamLines([this.streamOut, this.streamErr])) {
-            yield ok(line);
-        }
-
-        await this.cleanup();
-
-        const result = this.maybeThrow();
-        if (result.isErr()) return result;
-    }
-
-    protected override async thenImpl(): Promise<Result<Output, Error>> {
-        const p = this.process;
-        if (!p) return err(new Error("No process was started"));
-
-        const [stdout, stderr] = await readStreams([this.streamOut, this.streamErr]);
-
-        await this.cleanup();
-
-        const output: Output = {
-            stdout,
-            stderr,
-            exitCode: this.exitCode,
-        };
-        const result = this.maybeThrow(output);
-        if (result.isErr()) return result;
-
-        return ok(output);
-    }
-
-    protected maybeThrow(output?: Output): Result<void, Error> {
-        if (this.thrownError) return err(this.thrownError);
-
-        const shouldThrowOnError =
-            this.options.throwOnError && this.exitCode !== 0 && this.exitCode !== undefined;
-        if (!shouldThrowOnError) return ok();
-
-        return err(new NonZeroExitError(this, output));
-    }
-
-    protected override child() {
-        return new Process({ stdin: this });
-    }
-}
-
-export const exec: Exec = (...params: ExecParams): any => {
-    const self = new Process();
-
-    return BaseProcess["execImpl"](self, params);
-};
+export type { Output } from "../shared/types";
+export type { Exec, ProcessInstance, ProcessOptions } from "./types";

src/common/nil.ts

@@ -0,0 +1,77 @@
+import { Err, Ok } from "@/result";
+
+import { NonZeroExitError } from "../shared/error";
+import { BaseProcess } from "../shared/process";
+import { readStreamLines, readStreams } from "../shared/stream";
+
+import type { Exec, ProcessInstance, ProcessOptions } from "./types";
+import type { ExecParams, Output } from "../shared/types";
+import type { Result } from "@/result";
+
+export class Process
+    extends BaseProcess<Result<Output, Error>, Result<string, Error>>
+    implements ProcessInstance
+{
+    declare exec: Exec;
+    declare pipe: Exec;
+
+    declare protected options: Partial<ProcessOptions>;
+
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(options?: Partial<ProcessOptions>) {
+        super(options);
+    }
+
+    override async *[Symbol.asyncIterator](): AsyncIterator<Result<string, Error>> {
+        const p = this.process;
+        if (!p) return Err(new Error("No process was started"));
+
+        for await (const line of readStreamLines([this.streamOut, this.streamErr])) {
+            yield Ok(line);
+        }
+
+        await this.cleanup();
+
+        const result = this.maybeThrow();
+        if (result.isErr()) return result;
+    }
+
+    protected override async thenImpl(): Promise<Result<Output, Error>> {
+        const p = this.process;
+        if (!p) return Err(new Error("No process was started"));
+
+        const [stdout, stderr] = await readStreams([this.streamOut, this.streamErr]);
+
+        await this.cleanup();
+
+        const output: Output = {
+            stdout,
+            stderr,
+            exitCode: this.exitCode,
+        };
+        const result = this.maybeThrow(output);
+        if (result.isErr()) return result;
+
+        return Ok(output);
+    }
+
+    protected maybeThrow(output?: Output): Result<void, Error> {
+        if (this.thrownError) return Err(this.thrownError);
+
+        const shouldThrowOnError =
+            this.options.throwOnError && this.exitCode !== 0 && this.exitCode !== undefined;
+        if (!shouldThrowOnError) return Ok();
+
+        return Err(new NonZeroExitError(this, output));
+    }
+
+    protected override child() {
+        return new Process({ stdin: this });
+    }
+}
+
+export const exec: Exec = (...params: ExecParams): any => {
+    const self = new Process();
+
+    return BaseProcess["execImpl"](self, params);
+};

src/common/throttle.ts

@@ -6,7 +6,7 @@ import type {
     BaseProcessInstance,
     BaseProcessOptions,
     Output,
-} from "../types";
+} from "../shared/types";
 import type { Result } from "@/result";
 
 export type ProcessOptions = BaseProcessOptions<ProcessInstance>;

src/exec/index.ts

@@ -1,7 +1,7 @@
 import { tokenizeArgs } from "args-tokenizer";
 
-import { getErrorMessage } from "@/common";
-import { isArray, isPlainObject, isString } from "@/remeda";
+import { isArray, isPlainObject, isString } from "@/fp";
+import { getErrorMessage } from "@/tools";
 
 import type {
     BaseProcessOptions,

src/exec/safe/index.ts

@@ -1,6 +1,5 @@
-import { isString } from "remeda";
-
-import { concatTemplateStrings, createPromiseWithResolvers } from "@/common";
+import { isString } from "@/fp";
+import { concatTemplateStrings, createPromiseWithResolvers } from "@/tools";
 
 import { isAbortError } from "./error";
 import {