docs(build): Add comprehensive JSDoc documentation and implement Echo logging system

Added extensive JSDoc documentation to core build modules and functions to improve developer experience and code clarity. This update includes detailed descriptions, parameter explanations, and usage examples for Build.ts, Exec.ts, File.ts, JSON.ts, Merge.ts, Entry.ts, and related interfaces.

Implemented a new `Echo` function and corresponding interface to control command output verbosity based on log levels. The `Exec` function was updated to accept an optional `Echo` callback, enabling filtered output for child processes. The `Build` function now utilizes this `Echo` function to stream `tsc` and `tsc-alias` output.

Introduced `Level` type and variable definitions, which utilize ESBuild's `LogLevel` to manage build verbosity. Additionally, created `Source/Type/Level.ts` and `Source/Variable/Level.ts` to support the new logging infrastructure.

Author: NikolaRHristov

Source/Class/Build.ts

@@ -3,6 +3,41 @@
 /**
  * @module Build
  *
+ * CLI command for running the build process using Commander.js.
+ *
+ * This module defines a command-line interface for the build system. It provides
+ * options for specifying files to build, custom ESBuild/TypeScript configurations,
+ * and watch mode for continuous rebuilding.
+ *
+ * @example
+ * Basic usage - build all TypeScript files:
+ * ```bash
+ * node Class/Build.js "Source/**\/*.ts"
+ * ```
+ *
+ * @example
+ * Build with custom ESBuild configuration:
+ * ```bash
+ * node Class/Build.js "Source/**\/*.ts" --ESBuild ./config/esbuild.js
+ * ```
+ *
+ * @example
+ * Build with custom TypeScript configuration:
+ * ```bash
+ * node Class/Build.js "Source/**\/*.ts" --TypeScript ./tsconfig.build.json
+ * ```
+ *
+ * @example
+ * Enable watch mode for continuous builds:
+ * ```bash
+ * node Class/Build.js "Source/**\/*.ts" --Watch
+ * ```
+ *
+ * @example
+ * Combine options:
+ * ```bash
+ * node Class/Build.js "Index.ts" "Source/**\/*.ts" -E ./Config/ESBuild.js -T ./Config/TS.json --Watch
+ * ```
  */
 export default new (await import("commander")).Command()
 	.name("Build")

Source/Function/Build.ts

@@ -1,11 +1,87 @@
 import type { BuildOptions } from "esbuild";
 
+import Echo from "../Function/Echo.js";
 import type Interface from "../Interface/Build.js";
 import type Set from "../Interface/Build/Set.js";
 
 /**
  * @module Build
  *
+ * Main build function that processes files and performs builds using ESBuild and TypeScript.
+ *
+ * This function handles the complete build pipeline including:
+ * - Expanding file patterns (globbing)
+ * - Loading ESBuild configuration
+ * - Applying custom ESBuild presets
+ * - Running TypeScript compilation
+ * - Running tsc-alias for path aliases
+ * - Watching for changes (optional)
+ *
+ * @param File - An array of file patterns to build. Patterns can include wildcards (*, **).
+ * @param Option - Optional configuration object.
+ * @param Option.ESBuild - Path to a custom ESBuild configuration file or function.
+ * @param Option.TypeScript - Path to TypeScript configuration file (defaults to "tsconfig.json").
+ * @param Option.Watch - Enable watch mode to rebuild on file changes.
+ * @param Option.Exclude - Array of file patterns to exclude from the build.
+ *
+ * @returns Promise<void>
+ *
+ * @example
+ * Basic build:
+ * ```typescript
+ * import Build from "./Function/Build.js";
+ *
+ * await Build(["Source/**\/*.ts"]);
+ * ```
+ *
+ * @example
+ * Build with options:
+ * ```typescript
+ * await Build(
+ *   ["Source/**\/*.ts"],
+ *   {
+ *     ESBuild: "./Config/ESBuild.js",
+ *     TypeScript: "./tsconfig.build.json",
+ *     Watch: true,
+ *     Exclude: ["Source/**\/*.test.ts"],
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * Custom ESBuild configuration:
+ * ```typescript
+ * // Config/ESBuild.js - returns BuildOptions
+ * export default {
+ *   minify: true,
+ *   target: "es2020",
+ * };
+ * ```
+ *
+ * @example
+ * Custom ESBuild configuration function:
+ * ```typescript
+ * // Config/ESBuild.js - returns function
+ * import type BuildSetInterface from "../Interface/Build/Set.js";
+ * import type { BuildOptions } from "esbuild";
+ *
+ * export default async (current: BuildOptions) => {
+ *   return {
+ *     ...current,
+ *     plugins: [...(current.plugins ?? []), myPlugin],
+ *   };
+ * };
+ * ```
+ *
+ * @example
+ * Using the Pipe for dependency order:
+ * ```typescript
+ * import { Pipe } from "./Function/Build.js";
+ *
+ * // Pipe is populated with files in dependency order
+ * await Build(["Index.ts", "Source/**\/*.ts"]);
+ * console.log(Pipe); // ["Source/Module1.ts", "Source/Module2.ts", "Index.ts"]
+ * ```
  */
 export default (async (...[File, Option]) => {
 	for (const _File of File) {
@@ -81,9 +157,12 @@ export default (async (...[File, Option]) => {
 				}
 
 				try {
-					await Exec(`tsc -p ${Configuration.tsconfig}`);
+					await Exec(`tsc -p ${Configuration.tsconfig}`, Echo);
 
-					await Exec(`tsc-alias -f -p ${Configuration.tsconfig}`);
+					await Exec(
+						`tsc-alias -f -p ${Configuration.tsconfig}`,
+						Echo,
+					);
 				} catch (_Error) {
 					console.error(_Error);
 				}

Source/Function/Echo.ts

@@ -0,0 +1,49 @@
+import type { Echo } from "../Interface/Echo.js";
+import { Level } from "../Variable/Level.js";
+
+/**
+ * Echo callback function that filters output based on the Level setting.
+ *
+ * This function is used to control how output from child processes (stdout/stderr)
+ * is displayed. It provides a mechanism to filter or suppress output based on the
+ * current log level setting.
+ *
+ * @param Data - The output line data (trimmed whitespace)
+ * @param IsError - Optional boolean flag indicating if this is stderr output (true)
+ *                 or stdout output (false/undefined)
+ *
+ * @returns Promise<void>
+ *
+ * @example
+ * Default usage (respects Level variable):
+ * ```typescript
+ * import Echo from "./Function/Echo.js";
+ *
+ * await Echo("Build started...");
+ * await Echo("Error occurred", true);
+ * ```
+ *
+ * @example
+ * Custom echo function:
+ * ```typescript
+ * import type { Echo } from "./Interface/Echo.js";
+ * import { Level } from "./Variable/Level.js";
+ *
+ * const customEcho: Echo = async (Data: string, IsError?: boolean): Promise<void> => {
+ *   if (Level === "silent") {
+ *     return;
+ *   }
+ *   console.log(Data);
+ * };
+ * ```
+ */
+const Echo = async (Data: string, _IsError?: boolean): Promise<void> => {
+	// Suppress all output when Level is "silent"
+	if (Level === "silent") {
+		return;
+	}
+
+	console.log(Data);
+};
+
+export default Echo satisfies Echo as Echo;

Source/Function/Entry.ts

@@ -3,6 +3,44 @@ import type { BuildOptions } from "esbuild";
 /**
  * @module Entry
  *
+ * Function that filters entry points from build options based on exclusion patterns.
+ *
+ * This function removes entry points that match patterns in the `From` array.
+ * It supports various entry point formats: strings, objects with `in` property, and records.
+ *
+ * @param Current - The current ESBuild build options containing entryPoints.
+ *
+ * @param From - An array of file patterns to exclude from entry points.
+ *
+ * @returns The filtered array of entry points.
+ *
+ * @example
+ * Filtering common test files:
+ * ```typescript
+ * import Entry from "./Function/Entry.js";
+ * import { Exclude } from "./Function/Exclude.js";
+ *
+ * const options: BuildOptions = {
+ *   entryPoints: ["src/index.ts", "src/test.ts", "src/util.ts"],
+ * };
+ *
+ * const filtered = Entry(options, ["**\/*.test.ts"]);
+ * // Result: ["src/index.ts", "src/util.ts"]
+ * ```
+ *
+ * @example
+ * With object entry points:
+ * ```typescript
+ * const options: BuildOptions = {
+ *   entryPoints: [
+ *     { in: "src/main/index.ts", out: "main" },
+ *     { in: "src/test/index.ts", out: "test" },
+ *   ],
+ * };
+ *
+ * const filtered = Entry(options, ["**\/test\/**"]);
+ * // Result: [{ in: "src/main/index.ts", out: "main" }]
+ * ```
  */
 export default (Current: BuildOptions, From: string[]) => {
 	let _Filtered = [];

Source/Function/Exec.ts

@@ -1,12 +1,62 @@
 import type Interface from "../Interface/Exec.js";
 
+export const { default: EchoFn } = await import("../Function/Echo.js");
+
 /**
  * @module Exec
  *
+ * Function that executes a shell command and streams its output through an echo function.
+ *
+ * This function spawns a child process to execute the given command and streams
+ * the stdout and stderr through the provided echo callback function. This allows
+ * for custom handling of command output, including filtering by log level.
+ *
+ * @param Command - The shell command to execute.
+ * @param Echo - Optional callback function for handling stdout/stderr output.
+ *               If false, output is suppressed. If a function, it receives the output data.
+ *               Defaults to the default Echo function which respects the Level setting.
+ *
+ * @returns Promise<void>
+ *
+ * @example
+ * Basic execution with default echo:
+ * ```typescript
+ * import Exec from "./Function/Exec.js";
+ *
+ * await Exec("npm run build");
+ * ```
+ *
+ * @example
+ * Suppressing output:
+ * ```typescript
+ * await Exec("npm run test", false);
+ * ```
+ *
+ * @example
+ * Custom echo function:
+ * ```typescript
+ * import type { Echo } from "../Interface/Echo.js";
+ *
+ * const myEcho: Echo = async (data, isError) => {
+ *   if (isError) {
+ *     console.error(`[ERROR] ${data}`);
+ *   } else {
+ *     console.log(`[INFO] ${data}`);
+ *   }
+ * };
+ *
+ * await Exec("npm run build", myEcho);
+ * ```
+ *
+ * @example
+ * Multiple commands:
+ * ```typescript
+ * await Exec("npm install");
+ * await Exec("npm run build");
+ * await Exec("npm run test");
+ * ```
  */
-export default (async (
-	...[Command, Echo = async (Return) => console.log(Return)]
-) => {
+export default (async (...[Command, Echo = EchoFn]) => {
 	try {
 		const { stdout, stderr } = (await import("child_process")).exec(
 			Command,

Source/Function/File.ts

@@ -3,6 +3,38 @@ import type Interface from "../Interface/File.js";
 /**
  * @module File
  *
+ * Function that processes and loads files, with special TypeScript transpilation support.
+ *
+ * This function processes files based on their extension:
+ * - For TypeScript (.ts) files: transpiles to JavaScript using TypeScript compiler and writes the .js file
+ * - For all files: imports and returns the default export of the module
+ *
+ * @param Path - The file path to process.
+ *
+ * @returns Promise<any> The default export of the processed module.
+ *
+ * @example
+ * Loading a TypeScript configuration file:
+ * ```typescript
+ * import File from "./Function/File.js";
+ *
+ * const esbuildConfig = await File("./ESBuild.ts");
+ * // Returns the default export of the transpiled ESBuild.js
+ * ```
+ *
+ * @example
+ * Loading a JSON configuration (will be imported as-is):
+ * ```typescript
+ * const config = await File("./config.json");
+ * ```
+ *
+ * @example
+ * Dynamic configuration loading:
+ * ```typescript
+ * async function loadConfig<Option>(path: string): Promise<Option> {
+ *   return (await File(path)) as Option;
+ * }
+ * ```
  */
 export default (async (...[Path]) => {
 	if (Path.split(".").pop() === "ts") {

Source/Function/JSON.ts

@@ -3,6 +3,44 @@ import type Interface from "../Interface/JSON.js";
 /**
  * @module JSON
  *
+ * Function that reads and parses JSON files.
+ *
+ * This function reads a file from a specified directory and parses it as JSON.
+ * It is commonly used for loading configuration files (package.json, tsconfig.json, etc.).
+ *
+ * @param File - The name or path of the JSON file to read.
+ *
+ * @param From - An optional directory path from which to read the file.
+ *               If not provided, uses the current directory (".").
+ *
+ * @returns Promise<any> The parsed JSON content.
+ *
+ * @example
+ * Reading package.json:
+ * ```typescript
+ * import JSON from "./Function/JSON.js";
+ *
+ * const packageJson = await JSON("package.json");
+ * console.log(packageJson.version);
+ * ```
+ *
+ * @example
+ * Reading from a specific directory:
+ * ```typescript
+ * const tsConfig = await JSON("tsconfig.json", "./Source");
+ * ```
+ *
+ * @example
+ * Using inline with TypeScript configuration:
+ * ```typescript
+ * import JSON from "./Function/JSON.js";
+ * import { dirname, fileURLToPath } from "node:url";
+ *
+ * const config = await JSON(
+ *   "../../tsconfig.json",
+ *   dirname(fileURLToPath(import.meta.url))
+ * );
+ * ```
  */
 export default (async (...[File, From]) =>
 	JSON.parse(