@fedify/init 2.0.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2026 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+@fedify/init: Project initializer for Fedify
+============================================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides the project initialization functionality for [Fedify],
+an ActivityPub server framework.  It scaffolds new Fedify project directories
+with support for various web frameworks, package managers, key-value stores,
+and message queues.
+
+This package powers the `fedify init` command in the [`@fedify/cli`] toolchain,
+and can also be used as a standalone library.
+
+[JSR badge]: https://jsr.io/badges/@fedify/init
+[JSR]: https://jsr.io/@fedify/init
+[npm badge]: https://img.shields.io/npm/v/@fedify/init?logo=npm
+[npm]: https://www.npmjs.com/package/@fedify/init
+[Fedify]: https://fedify.dev/
+[`@fedify/cli`]: https://jsr.io/@fedify/cli
+
+
+Supported options
+-----------------
+
+The initializer supports the following project configurations:
+
+ -  **Web frameworks**: [Hono], [Nitro], [Next.js], [Elysia], [Express]
+ -  **Package managers**: Deno, pnpm, Bun, Yarn, npm
+ -  **Key-value stores**: Deno KV, Redis, PostgreSQL
+ -  **Message queues**: Deno KV, Redis, PostgreSQL, AMQP
+
+[Hono]: https://hono.dev/
+[Nitro]: https://nitro.build/
+[Next.js]: https://nextjs.org/
+[Elysia]: https://elysiajs.com/
+[Express]: https://expressjs.com/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@fedify/init  # Deno
+npm  add     @fedify/init  # npm
+pnpm add     @fedify/init  # pnpm
+yarn add     @fedify/init  # Yarn
+bun  add     @fedify/init  # Bun
+~~~~
+
+
+API
+---
+
+The package exports the following:
+
+ -  `runInit`: The main initialization action handler.
+ -  `initCommand`: The CLI command definition for `init`.
+
+~~~~ typescript
+import { initCommand, runInit } from "@fedify/init";
+~~~~
+
+
+Test
+----
+
+The `test-init` task is useful for contributors working on `@fedify/init`,
+especially when adding support for a new framework/library or modifying the
+scaffolding logic.  It tests the project initialization by running
+`fedify init` across all combinations of supported options on temporary
+directories, verifying that the generated projects are valid.
+
+To run the test using Deno:
+
+~~~~ sh
+deno task test-init
+~~~~
+
+Or using pnpm:
+
+~~~~ sh
+pnpm test-init
+~~~~
+
+You can also filter specific options to test a subset of combinations:
+
+~~~~ sh
+deno task test-init -w hono -p deno
+~~~~
+
+Use `--no-dry-run` to test with actual file creation and dependency
+installation, or `--no-hyd-run` to only log outputs without creating files.

package/dist/action/configs.mjs

@@ -0,0 +1,89 @@
+import { merge } from "../utils.mjs";
+import biome_default from "../json/biome.mjs";
+import vscode_settings_for_deno_default from "../json/vscode-settings-for-deno.mjs";
+import vscode_settings_default from "../json/vscode-settings.mjs";
+import { PACKAGES_PATH } from "./const.mjs";
+import { getDependencies, getDevDependencies, joinDepsReg } from "./deps.mjs";
+import { uniq } from "es-toolkit";
+import { realpathSync } from "node:fs";
+import { join, relative } from "node:path";
+import { concat, filter, keys, map, pick, pipe, toArray } from "@fxts/core/index.js";
+
+//#region src/action/configs.ts
+/**
+* Loads Deno configuration object with compiler options, unstable features, and tasks.
+* Combines unstable features required by KV store and message queue with framework-specific options.
+*
+* @param param0 - Destructured initialization data containing KV, MQ, initializer, and directory
+* @returns Configuration object with path and Deno-specific settings
+*/
+const loadDenoConfig = (data) => ({
+	path: "deno.json",
+	data: {
+		...pick(["compilerOptions", "tasks"], data.initializer),
+		unstable: getUnstable(data),
+		nodeModulesDir: "auto",
+		imports: joinDepsReg("deno")(getDependencies(data)),
+		lint: { plugins: ["jsr:@fedify/lint"] },
+		...data.testMode ? { links: getLinks(data) } : {}
+	}
+});
+const getUnstable = ({ kv: { denoUnstable: kv = [] }, mq: { denoUnstable: mq = [] } }) => pipe(["temporal"], concat(kv), concat(mq), toArray, uniq);
+const getLinks = ({ kv, mq, initializer, dir }) => pipe({ "@fedify/fedify": "" }, merge(initializer.dependencies), merge(kv.dependencies), merge(mq.dependencies), keys, filter((dep) => dep.includes("@fedify/")), map((dep) => dep.replace("@fedify/", "")), map((dep) => join(PACKAGES_PATH, dep)), map((absolutePath) => realpathSync(absolutePath)), map((realAbsolutePath) => relative(realpathSync(dir), realAbsolutePath)), toArray);
+/**
+* Loads TypeScript configuration object for Node.js/Bun projects.
+* Uses compiler options from the framework initializer.
+*
+* @param param0 - Destructured initialization data containing initializer and directory
+* @returns Configuration object with path and TypeScript compiler options
+*/
+const loadTsConfig = ({ initializer, dir }) => ({
+	path: join(dir, "tsconfig.json"),
+	data: { compilerOptions: initializer.compilerOptions }
+});
+/**
+* Loads package.json configuration object for Node.js/Bun projects.
+* Sets up ES modules and includes framework-specific npm scripts.
+*
+* @param param0 - Destructured initialization data containing initializer and directory
+* @returns Configuration object with path and package.json settings
+*/
+const loadPackageJson = (data) => ({
+	path: "package.json",
+	data: {
+		type: "module",
+		scripts: data.initializer.tasks,
+		dependencies: getDependencies(data),
+		devDependencies: getDevDependencies(data)
+	}
+});
+/**
+* Configuration objects for various development tool setup files.
+* Contains predefined configurations for code formatting, VS Code settings, and extensions
+* based on the project type (Node.js/Bun or Deno).
+*/
+const devToolConfigs = {
+	biome: {
+		path: join("biome.json"),
+		data: biome_default
+	},
+	vscExt: {
+		path: join(".vscode", "extensions.json"),
+		data: { recommendations: ["biomejs.biome", "dbaeumer.vscode-eslint"] }
+	},
+	vscSet: {
+		path: join(".vscode", "settings.json"),
+		data: vscode_settings_default
+	},
+	vscSetDeno: {
+		path: join(".vscode", "settings.json"),
+		data: vscode_settings_for_deno_default
+	},
+	vscExtDeno: {
+		path: join(".vscode", "extensions.json"),
+		data: { recommendations: ["denoland.vscode-deno"] }
+	}
+};
+
+//#endregion
+export { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig };

package/dist/action/const.mjs

@@ -0,0 +1,7 @@
+import { join } from "node:path";
+
+//#region src/action/const.ts
+const PACKAGES_PATH = join(import.meta.dirname, "..", "..", "..");
+
+//#endregion
+export { PACKAGES_PATH };

package/dist/action/deps.mjs

@@ -0,0 +1,50 @@
+import { merge, replace } from "../utils.mjs";
+import { PACKAGE_VERSION } from "../lib.mjs";
+import { PACKAGES_PATH } from "./const.mjs";
+import { isDeno } from "./utils.mjs";
+import { always, entries, filter, fromEntries, map, pipe, when } from "@fxts/core";
+import { join as join$1 } from "node:path";
+
+//#region src/action/deps.ts
+/**
+* Gathers all dependencies required for the project based on the initializer,
+* key-value store, and message queue configurations.
+*
+* @param data - Web Framework initializer, key-value store and
+*               message queue descriptions
+* @returns A record of dependencies with their versions
+*/
+const getDependencies = ({ initializer, kv, mq, testMode, packageManager }) => pipe({
+	"@fedify/fedify": PACKAGE_VERSION,
+	"@fedify/vocab": PACKAGE_VERSION,
+	"@logtape/logtape": "^2.0.0"
+}, merge(initializer.dependencies), merge(kv.dependencies), merge(mq.dependencies), when(always(testMode), isDeno({ packageManager }) ? removeFedifyDeps : addLocalFedifyDeps), normalizePackageNames(packageManager));
+const removeFedifyDeps = (deps) => pipe(deps, entries, filter(([name]) => !name.includes("@fedify")), fromEntries);
+const addLocalFedifyDeps = (deps) => pipe(deps, entries, map(when(([name]) => name.includes("@fedify/"), ([name, _version]) => [name, convertFedifyToLocal(name)])), fromEntries);
+const convertFedifyToLocal = (name) => pipe(name, replace("@fedify/", ""), (pkg) => join$1(PACKAGES_PATH, pkg));
+/** Gathers all devDependencies required for the project based on the
+* initializer, key-value store, and message queue configurations,
+* including Biome for linting/formatting.
+*
+* @param data - Web Framework initializer, key-value store
+*               and message queue descriptions
+* @returns A record of devDependencies with their versions
+*/
+const getDevDependencies = ({ initializer, kv, mq, packageManager }) => pipe({ "@biomejs/biome": "^2.2.4" }, merge(initializer.devDependencies), merge(kv.devDependencies), merge(mq.devDependencies), normalizePackageNames(packageManager));
+/**
+* Joins package names with their versions for installation dependencies.
+* For Deno, it prefixes packages with 'jsr:'
+* unless they already start with 'npm:' or 'jsr:'.
+*
+* @param data - Package manager and dependencies to be joined with versions
+* @returns \{ name: `${registry}:${package}@${version}` } for deno
+*/
+const joinDepsReg = (pm) => (dependencies) => pipe(dependencies, entries, map(([name, version]) => {
+	return [name.substring(4), version.startsWith("npm:") || version.startsWith("jsr:") ? version : `${name}@${getPackageVersion(pm, version)}`];
+}), fromEntries);
+const getPackageVersion = (pm, version) => pm !== "deno" && version.includes("+") ? version.substring(0, version.indexOf("+")) : version;
+const normalizePackageNames = (pm) => (deps) => pipe(deps, entries, map(([name, version]) => [getPackageName(pm, name), version]), fromEntries);
+const getPackageName = (pm, name) => pm !== "deno" ? name.startsWith("npm:") ? name.replace("npm:", "") : name : name.startsWith("npm:") ? name : `jsr:${name}`;
+
+//#endregion
+export { getDependencies, getDevDependencies, joinDepsReg };

package/dist/action/dir.mjs

@@ -0,0 +1,13 @@
+import { mkdir } from "node:fs/promises";
+
+//#region src/action/dir.ts
+/**
+* Creates the target directory if it does not exist.
+*
+* @param data - The directory
+* @returns A promise that resolves when the directory is created
+*/
+const makeDirIfHyd = ({ dir }) => mkdir(dir, { recursive: true });
+
+//#endregion
+export { makeDirIfHyd };

package/dist/action/env.mjs

@@ -0,0 +1,10 @@
+import { notEmpty } from "../utils.mjs";
+import { noticeConfigEnv, noticeEnvKeyValue } from "./notice.mjs";
+import { entries, forEach, pipeLazy, tap, toArray, when } from "@fxts/core";
+
+//#region src/action/env.ts
+const recommendConfigEnv = pipeLazy((data) => data.env, entries, toArray, when(notEmpty, tap(noticeConfigEnv)), forEach(noticeEnvKeyValue));
+var env_default = recommendConfigEnv;
+
+//#endregion
+export { env_default as default };

package/dist/action/install.mjs

@@ -0,0 +1,17 @@
+import { CommandError, runSubCommand } from "../utils.mjs";
+import { apply, pipe } from "@fxts/core";
+
+//#region src/action/install.ts
+const installDependencies = (data) => pipe(data, ({ packageManager, dir }) => [[packageManager, "install"], { cwd: dir }], apply(runSubCommand)).catch((e) => {
+	if (e instanceof CommandError) {
+		console.error(`Failed to install dependencies using ${data.packageManager}.`);
+		console.error("Command:", e.commandLine);
+		if (e.stderr) console.error("Error:", e.stderr);
+		throw e;
+	}
+	throw e;
+});
+var install_default = installDependencies;
+
+//#endregion
+export { install_default as default };

package/dist/action/mod.d.mts

@@ -0,0 +1,23 @@
+import { InitCommand } from "../command.mjs";
+import { InitCommandData } from "../types.mjs";
+
+//#region src/action/mod.d.ts
+
+/**
+ * Execution flow of the `runInit` function:
+ *
+ * 1. Receives options of type `InitCommand`.
+ * 2. Prints a dinosaur ASCII art via `drawDinosaur`.
+ * 3. Prompts the user for options via `askOptions`,
+ *    converting `InitCommand` into `InitCommandOptions`.
+ * 4. Displays the selected options via `noticeOptions`.
+ * 5. Converts `InitCommandOptions` into `InitCommandData` via `setData`.
+ * 6. Branches based on `isDry`:
+ *    - If dry run, executes `handleDryRun`.
+ *    - Otherwise, executes `handleHydRun`.
+ * 7. Recommends configuration environment via `recommendConfigEnv`.
+ * 8. Shows how to run the project via `noticeHowToRun`.
+ */
+declare const runInit: (options: InitCommand) => Promise<InitCommandData>;
+//#endregion
+export { runInit };

package/dist/action/mod.mjs

@@ -0,0 +1,38 @@
+import { set } from "../utils.mjs";
+import ask_default from "../ask/mod.mjs";
+import { makeDirIfHyd } from "./dir.mjs";
+import { drawDinosaur, noticeHowToRun, noticeOptions, noticePrecommand } from "./notice.mjs";
+import env_default from "./env.mjs";
+import install_default from "./install.mjs";
+import { hasCommand, isDry } from "./utils.mjs";
+import { patchFiles, recommendPatchFiles } from "./patch.mjs";
+import precommand_default from "./precommand.mjs";
+import recommend_default from "./recommend.mjs";
+import set_default from "./set.mjs";
+import { pipe, tap, unless, when } from "@fxts/core";
+import process from "node:process";
+
+//#region src/action/mod.ts
+/**
+* Execution flow of the `runInit` function:
+*
+* 1. Receives options of type `InitCommand`.
+* 2. Prints a dinosaur ASCII art via `drawDinosaur`.
+* 3. Prompts the user for options via `askOptions`,
+*    converting `InitCommand` into `InitCommandOptions`.
+* 4. Displays the selected options via `noticeOptions`.
+* 5. Converts `InitCommandOptions` into `InitCommandData` via `setData`.
+* 6. Branches based on `isDry`:
+*    - If dry run, executes `handleDryRun`.
+*    - Otherwise, executes `handleHydRun`.
+* 7. Recommends configuration environment via `recommendConfigEnv`.
+* 8. Shows how to run the project via `noticeHowToRun`.
+*/
+const runInit = (options) => pipe(options, tap(drawDinosaur), setTestMode, ask_default, tap(noticeOptions), set_default, when(isDry, handleDryRun), unless(isDry, handleHydRun), tap(env_default), tap(noticeHowToRun));
+var action_default = runInit;
+const setTestMode = set("testMode", () => Boolean(process.env["FEDIFY_TEST_MODE"]));
+const handleDryRun = (data) => pipe(data, tap(when(hasCommand, noticePrecommand)), tap(recommendPatchFiles), tap(recommend_default));
+const handleHydRun = (data) => pipe(data, tap(makeDirIfHyd), tap(when(hasCommand, precommand_default)), tap(patchFiles), tap(install_default));
+
+//#endregion
+export { action_default as default };

package/dist/action/notice.mjs

@@ -0,0 +1,52 @@
+import { colors, printMessage } from "../utils.mjs";
+import { text } from "@optique/core";
+import { flow } from "es-toolkit";
+
+//#region src/action/notice.ts
+function drawDinosaur() {
+	const d = flow(colors.bgBlue, colors.black);
+	const f = colors.blue;
+	console.error(`\
+${d("             ___   ")}  ${f(" _____        _ _  __")}
+${d("            /'_')  ")}  ${f("|  ___|__  __| (_)/ _|_   _")}
+${d("     .-^^^-/  /    ")}  ${f("| |_ / _ \\/ _` | | |_| | | |")}
+${d("   __/       /     ")}  ${f("|  _|  __/ (_| | |  _| |_| |")}
+${d("  <__.|_|-|_|      ")}  ${f("|_|  \\___|\\__,_|_|_|  \\__, |")}
+${d("                   ")}  ${f("                      |___/")}
+`);
+}
+const noticeOptions = ({ packageManager, webFramework, kvStore, messageQueue }) => printMessage`
+  Package manager: ${packageManager};
+  Web framework: ${webFramework};
+  Key–value store: ${kvStore};
+  Message queue: ${messageQueue};
+`;
+function noticePrecommand({ initializer: { command: command$1 }, dir }) {
+	printMessage`📦 Would run command:`;
+	printMessage`  cd ${dir}`;
+	printMessage`  ${command$1.join(" ")}\n`;
+}
+const noticeFilesToCreate = () => printMessage`📄 Would create files:\n`;
+const noticeFilesToInsert = () => printMessage`Would create/update JSON files:\n`;
+const noticeDepsIfExist = () => printMessage`📦 Would install dependencies:`;
+const noticeDevDepsIfExist = () => printMessage`📦 Would install dev dependencies:`;
+const noticeDeps = ([name, version]) => printMessage`${name}@${version}`;
+function displayFile(path, content, emoji = "📄") {
+	printMessage`${emoji} ${path}`;
+	printMessage`${"─".repeat(60)}`;
+	printMessage`${content}`;
+	printMessage`${"─".repeat(60)}\n`;
+}
+const noticeConfigEnv = () => printMessage`Note that you probably want to edit the ${".env"} file.
+It currently contains the following values:\n`;
+const noticeEnvKeyValue = ([key, value]) => {
+	printMessage`${text(`  ${key}='${value}'`)}`;
+};
+const noticeHowToRun = ({ initializer: { instruction, federationFile } }) => printMessage`
+${instruction}
+    
+Start by editing the ${text(federationFile)} file to define your federation!
+`;
+
+//#endregion
+export { displayFile, drawDinosaur, noticeConfigEnv, noticeDeps, noticeDepsIfExist, noticeDevDepsIfExist, noticeEnvKeyValue, noticeFilesToCreate, noticeFilesToInsert, noticeHowToRun, noticeOptions, noticePrecommand };

package/dist/action/patch.mjs

@@ -0,0 +1,143 @@
+import { formatJson, merge, replaceAll, set } from "../utils.mjs";
+import { createFile, throwUnlessNotExists } from "../lib.mjs";
+import { displayFile, noticeFilesToCreate, noticeFilesToInsert } from "./notice.mjs";
+import { joinDir, stringifyEnvs } from "./utils.mjs";
+import { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig } from "./configs.mjs";
+import { getImports, loadFederation, loadLogging } from "./templates.mjs";
+import { always, apply, entries, map, pipe, pipeLazy, tap } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+import { readFile } from "node:fs/promises";
+
+//#region src/action/patch.ts
+/**
+* Main function that initializes the project by creating necessary files and configurations.
+* Handles both dry-run mode (recommending files) and actual file creation.
+* Orchestrates the entire file generation and writing process.
+*
+* @param data - The initialization command data containing project
+*               configuration
+* @returns A processed data object with files and JSONs ready for creation
+*/
+const patchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), createFiles);
+const recommendPatchFiles = (data) => pipe(data, set("files", getFiles), set("jsons", getJsons), recommendFiles);
+/**
+* Generates text-based files (TypeScript, environment files) for the project.
+* Creates federation configuration, logging setup, environment variables, and
+* framework-specific files by processing templates and combining them with
+* project-specific data.
+*
+* @param data - The initialization command data
+* @returns A record of file paths to their string content
+*/
+const getFiles = (data) => ({
+	[data.initializer.federationFile]: loadFederation({
+		imports: getImports(data),
+		...data
+	}),
+	[data.initializer.loggingFile]: loadLogging(data),
+	".env": stringifyEnvs(data.env),
+	...data.initializer.files
+});
+/**
+* Generates JSON configuration files based on the package manager type.
+* Creates different sets of configuration files for Deno vs other environments,
+* including compiler configs, package manifests, and development
+* tool configurations.
+*
+* @param data - The initialization command data
+* @returns A record of file paths to their JSON object content
+*/
+const getJsons = (data) => data.packageManager === "deno" ? {
+	"deno.json": loadDenoConfig(data).data,
+	[devToolConfigs["vscSetDeno"].path]: devToolConfigs["vscSetDeno"].data,
+	[devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data
+} : {
+	...data.initializer.compilerOptions ? { "tsconfig.json": loadTsConfig(data).data } : {},
+	"package.json": loadPackageJson(data).data,
+	[devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
+	[devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
+	[devToolConfigs["vscExt"].path]: devToolConfigs["vscExt"].data
+};
+/**
+* Handles dry-run mode by recommending files to be created without actually
+* creating them.
+* Displays what files would be created and shows their content for user review,
+* so users can preview the initialization process before committing to it.
+*
+* @param data - The initialization command data with files and JSONs prepared
+* @returns The processed data with recommendations displayed
+*/
+const recommendFiles = (data) => pipe(data, tap(noticeFilesToCreate), tap(processAllFiles(displayFile)), tap(noticeFilesToInsert), set("files", ({ jsons }) => jsons), tap(processAllFiles(displayFile)));
+/**
+* Actually creates files on the filesystem during normal execution.
+* Merges text files and JSON files together and writes them to disk.
+* This performs the actual file system operations to initialize the project.
+*
+* @param data - The initialization command data with files and JSONs prepared
+* @returns The processed data after files have been created
+*/
+const createFiles = (data) => pipe(data, set("files", ({ jsons, files }) => toMerged(files, jsons)), tap(processAllFiles(createFile)));
+/**
+* Processes all files with a given processing function.
+* Takes a processor (either display or create) and applies it to all files
+* in the target directory, handling path resolution and content patching.
+*
+* @param process - Function to process each file (either display or create)
+* @returns A function that processes all files in the given directory with the provided processor
+*/
+const processAllFiles = (process) => ({ dir, files }) => pipe(files, entries, map(pipeLazy(joinDir(dir), apply(patchContent), apply(process))), Array.fromAsync);
+/**
+* Patches file content by either merging JSON or appending text content.
+* Handles existing files by reading their current content and intelligently
+* combining it with new content based on the content type (JSON vs text).
+*
+* @param path - The file path to patch
+* @param content - The new content (either string or object)
+* @returns A tuple containing the file path and the final content string
+*/
+async function patchContent(path, content) {
+	const prev = await readFileIfExists(path);
+	return [path, typeof content === "object" ? mergeJson(prev, content) : appendText(prev, content)];
+}
+/**
+* Merges new JSON data with existing JSON content and formats the result.
+* Parses existing JSON content (if any) and deep merges it with new data,
+* then formats the result for consistent output.
+* Supports JSONC (JSON with Comments) by removing comments before parsing.
+*
+* @param prev - The previous JSON content as string
+* @param data - The new data object to merge
+* @returns Formatted JSON string with merged content
+*/
+const mergeJson = (prev, data) => pipe(prev ? JSON.parse(removeJsonComments(prev)) : {}, merge(data), formatJson);
+/**
+* Removes single-line (//) and multi-line (/* *\/) comments from JSON string.
+* This allows parsing JSONC (JSON with Comments) files.
+*
+* @param jsonString - The JSON string potentially containing comments
+* @returns JSON string with comments removed
+*/
+const removeJsonComments = (jsonString) => pipe(jsonString, replaceAll(/\/\/.*$/gm, ""), replaceAll(/\/\*[\s\S]*?\*\//g, ""));
+/**
+* Appends new text content to existing text content line by line.
+* Concatenates new content lines with existing content lines,
+* preserving line structure and formatting.
+*
+* @param prev - The previous text content
+* @param data - The new text content to append
+* @returns Combined text content as a single string
+*/
+const appendText = (prev, data) => prev ? `${prev}\n${data}` : data;
+/**
+* Safely reads a file if it exists, returns empty string if it doesn't exist.
+* Provides error handling to distinguish between "file not found" and other
+* file system errors, throwing only for unexpected errors.
+*
+* @param path - The file path to read
+* @returns The file content as string, or empty string if file doesn't exist
+* @throws Error if file access fails for reasons other than file not existing
+*/
+const readFileIfExists = (path) => readFile(path, "utf8").catch(pipeLazy(tap(throwUnlessNotExists), always("")));
+
+//#endregion
+export { patchFiles, recommendPatchFiles };

package/dist/action/precommand.mjs

@@ -0,0 +1,25 @@
+import { CommandError, exit, runSubCommand } from "../utils.mjs";
+
+//#region src/action/precommand.ts
+/**
+* Runs the precommand specified in the initializer to set up the project.
+*
+* @param data - The initialization command data containing the initializer command and directory
+* @returns A promise that resolves when the precommand has been executed
+*/
+const runPrecommand = ({ initializer: { command }, dir }) => runSubCommand(command, {
+	cwd: dir,
+	stdio: "inherit"
+}).catch((e) => {
+	if (e instanceof CommandError) {
+		console.error("Failed to run the precommand.");
+		console.error("Command:", e.commandLine);
+		if (e.stderr) console.error("Error:", e.stderr);
+		if (e.stdout) console.error("Output:", e.stdout);
+	} else console.error("Failed to run the precommand:", e);
+	exit(1);
+});
+var precommand_default = runPrecommand;
+
+//#endregion
+export { precommand_default as default };

package/dist/action/recommend.mjs

@@ -0,0 +1,21 @@
+import { notEmpty } from "../utils.mjs";
+import { noticeDeps, noticeDepsIfExist, noticeDevDepsIfExist } from "./notice.mjs";
+import { isDeno } from "./utils.mjs";
+import { getDependencies, getDevDependencies } from "./deps.mjs";
+import { map, peek, pipeLazy, tap, unless, when } from "@fxts/core";
+
+//#region src/action/recommend.ts
+const recommendDeps = pipeLazy(getDependencies, Object.entries, when(notEmpty, tap(noticeDepsIfExist)), peek(noticeDeps));
+const recommendDevDeps = pipeLazy(getDevDependencies, Object.entries, when(notEmpty, tap(noticeDevDepsIfExist)), map(noticeDeps));
+/**
+* Recommends dependencies and devDependencies to be added to package.json.
+* Skips devDependencies recommendation if the package manager is Deno.
+*
+* @param data - The initialization command data
+* @returns An InitCommandIo function that performs the recommendation
+*/
+const recommendDependencies = pipeLazy(tap(recommendDeps), unless(isDeno, tap(recommendDevDeps)));
+var recommend_default = recommendDependencies;
+
+//#endregion
+export { recommend_default as default };

package/dist/action/set.mjs

@@ -0,0 +1,28 @@
+import { merge, set } from "../utils.mjs";
+import { kvStores, messageQueues } from "../lib.mjs";
+import webframeworks_default from "../webframeworks.mjs";
+import { pipe } from "@fxts/core";
+import { existsSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { basename, normalize } from "node:path";
+
+//#region src/action/set.ts
+/**
+* Set all necessary data for initializing the project.
+* This function orchestrates the setting of project name, initializer,
+* key-value store, message queue, and environment variables by calling
+* individual setter functions for each piece of data.
+*
+* @param data - The initial command options provided by the user
+* @returns A promise resolving to a complete InitCommandData object
+*/
+const setData = (data) => pipe(data, setProjectName, setInitializer, setKv, setMq, setEnv);
+var set_default = setData;
+const setProjectName = set("projectName", async ({ dir }) => basename(existsSync(dir) ? await realpath(dir) : normalize(dir)));
+const setInitializer = set("initializer", (data) => webframeworks_default[data.webFramework].init(data));
+const setKv = set("kv", ({ kvStore }) => kvStores[kvStore]);
+const setMq = set("mq", ({ messageQueue }) => messageQueues[messageQueue]);
+const setEnv = set("env", ({ kv, mq }) => merge(kv.env)(mq.env));
+
+//#endregion
+export { set_default as default };