@fedify/cli 2.0.0-pr.479.1922 → 2.0.0

package/dist/init/action/deps.js

@@ -1,50 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { merge, replace } from "../../utils.js";
-import { PACKAGE_VERSION } from "../lib.js";
-import { PACKAGES_PATH } from "./const.js";
-import { isDeno } from "./utils.js";
-import { join } from "node:path";
-import { always, entries, filter, fromEntries, map, pipe, when } from "@fxts/core";
-
-//#region src/init/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,
-	"@logtape/logtape": "^1.1.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(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]) => [name.substring(4), `${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/init/action/dir.js

@@ -1,16 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { mkdir } from "node:fs/promises";
-
-//#region src/init/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/init/action/env.js

@@ -1,13 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { notEmpty } from "../../utils.js";
-import { noticeConfigEnv, noticeEnvKeyValue } from "./notice.js";
-import { entries, forEach, pipeLazy, tap, toArray, when } from "@fxts/core";
-
-//#region src/init/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/init/action/install.js

@@ -1,20 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { CommandError, runSubCommand } from "../../utils.js";
-import { apply, pipe } from "@fxts/core";
-
-//#region src/init/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/init/action/mod.js

@@ -1,39 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import ask_default from "../ask/mod.js";
-import { makeDirIfHyd } from "./dir.js";
-import { drawDinosaur, noticeHowToRun, noticeOptions, noticePrecommand } from "./notice.js";
-import env_default from "./env.js";
-import install_default from "./install.js";
-import { hasCommand, isDry } from "./utils.js";
-import { patchFiles, recommendPatchFiles } from "./patch.js";
-import precommand_default from "./precommand.js";
-import recommend_default from "./recommend.js";
-import set_default from "./set.js";
-import { pipe, tap, unless, when } from "@fxts/core";
-
-//#region src/init/action/mod.ts
-/**
-*             options: InitCommand
-*                ├ drawDinosaur
-*          ┌─────┴──────┐
-*          │ askOptions │ InitCommand -> InitCommandOptions
-*          └─────┬──────┘
-*                ├ noticeOptions
-*           ┌────┴────┐
-*           │ setData │ InitCommandOptions -> InitCommandData
-*           └────┬────┘
-*              ┌─┴─┐ isDry
-* handleDryRun ┤   ├ handleHydRun
-*              └─┬─┘
-*                ├ recommendConfigEnv
-*                ├ noticeHowToRun
-*/
-const runInit = (options) => pipe(options, tap(drawDinosaur), ask_default, tap(noticeOptions), set_default, when(isDry, handleDryRun), unless(isDry, handleHydRun), tap(env_default), tap(noticeHowToRun));
-var action_default = runInit;
-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/init/action/notice.js

@@ -1,55 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { colors, printMessage } from "../../utils.js";
-import { text } from "@optique/core";
-import { flow } from "es-toolkit";
-
-//#region src/init/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/init/action/patch.js

@@ -1,147 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { formatJson, merge, replaceAll, set } from "../../utils.js";
-import { createFile, throwUnlessNotExists } from "../lib.js";
-import { displayFile, noticeFilesToCreate, noticeFilesToInsert } from "./notice.js";
-import { joinDir, stringifyEnvs } from "./utils.js";
-import { devToolConfigs, loadDenoConfig, loadPackageJson, loadTsConfig } from "./configs.js";
-import { getImports, loadFederation, loadLogging } from "./templates.js";
-import { readFile } from "node:fs/promises";
-import { always, apply, entries, map, pipe, pipeLazy, tap } from "@fxts/core";
-import { toMerged } from "es-toolkit";
-
-//#region src/init/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);
-	const data = typeof content === "object" ? mergeJson(prev, content) : appendText(prev, content);
-	return [path, data];
-}
-/**
-* 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/init/action/precommand.js

@@ -1,28 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { CommandError, exit, runSubCommand } from "../../utils.js";
-
-//#region src/init/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/init/action/recommend.js

@@ -1,24 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { notEmpty } from "../../utils.js";
-import { noticeDeps, noticeDepsIfExist, noticeDevDepsIfExist } from "./notice.js";
-import { isDeno } from "./utils.js";
-import { getDependencies, getDevDependencies } from "./deps.js";
-import { map, peek, pipeLazy, tap, unless, when } from "@fxts/core";
-
-//#region src/init/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/init/action/set.js

@@ -1,31 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { merge, set } from "../../utils.js";
-import webframeworks_default from "../webframeworks.js";
-import { kvStores, messageQueues } from "../lib.js";
-import { basename, normalize } from "node:path";
-import { realpath } from "node:fs/promises";
-import { pipe } from "@fxts/core";
-import { existsSync } from "node:fs";
-
-//#region src/init/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 };

package/dist/init/action/templates.js

@@ -1,58 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { replace } from "../../utils.js";
-import { readTemplate } from "../lib.js";
-import { entries, join, map, pipe } from "@fxts/core";
-import { toMerged } from "es-toolkit";
-
-//#region src/init/action/templates.ts
-/**
-* Loads the federation configuration file content from template.
-* Reads the default federation template and replaces placeholders with actual configuration values.
-*
-* @param param0 - Configuration object containing imports, project name, KV store, message queue, and package manager
-* @returns The complete federation configuration file content as a string
-*/
-const loadFederation = ({ imports, projectName, kv, mq, packageManager }) => pipe("defaults/federation.ts", readTemplate, replace(/\/\* imports \*\//, imports), replace(/\/\* logger \*\//, JSON.stringify(projectName)), replace(/\/\* kv \*\//, convertEnv(kv.object, packageManager)), replace(/\/\* queue \*\//, convertEnv(mq.object, packageManager)));
-/**
-* Loads the logging configuration file content from template.
-* Reads the default logging template and replaces the project name placeholder.
-*
-* @param param0 - Destructured object containing the project name
-* @returns The complete logging configuration file content as a string
-*/
-const loadLogging = ({ projectName }) => pipe("defaults/logging.ts", readTemplate, replace(/\/\* project name \*\//, JSON.stringify(projectName)));
-/**
-* Generates import statements for KV store and message queue dependencies.
-* Merges imports from both KV and MQ configurations and creates proper ES module import syntax.
-*
-* @param param0 - Destructured object containing kv and mq configurations
-* @returns A multi-line string containing all necessary import statements
-*/
-const getImports = ({ kv, mq }) => pipe(toMerged(kv.imports, mq.imports), entries, map(([module, { "default": defaultImport = "",...imports }]) => [
-	module,
-	defaultImport,
-	getAlias(imports)
-]), map(([module, defaultImport, namedImports]) => `import ${[defaultImport, namedImports.length > 0 ? `{ ${namedImports} }` : ""].filter((x) => x.length > 0).join(", ")} from ${JSON.stringify(module)};`), join("\n"));
-/**
-* Converts import mappings to named import string with aliases.
-* Creates proper ES module named import syntax, using aliases when the import name differs from the local name.
-*
-* @param imports - A record mapping import names to their local aliases
-* @returns A comma-separated string of named imports with aliases where needed
-*/
-const getAlias = (imports) => pipe(imports, entries, map(([name, alias]) => name === alias ? name : `${name} as ${alias}`), join(", "));
-const ENV_REG_EXP = /process\.env\.(\w+)/g;
-/**
-* Converts Node.js environment variable access to Deno-compatible syntax when needed.
-* Transforms `process.env.VAR_NAME` to `Deno.env.get("VAR_NAME")` for Deno projects.
-*
-* @param obj - The object string containing potential environment variable references
-* @param pm - The package manager (runtime) being used
-* @returns The converted object string with appropriate environment variable access syntax
-*/
-const convertEnv = (obj, pm) => pm === "deno" && ENV_REG_EXP.test(obj) ? obj.replaceAll(ENV_REG_EXP, (_, g1) => `Deno.env.get("${g1}")`) : obj;
-
-//#endregion
-export { getImports, loadFederation, loadLogging };

package/dist/init/action/utils.js

@@ -1,50 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { join } from "node:path";
-
-//#region src/init/action/utils.ts
-const isDry = ({ dryRun }) => dryRun;
-const hasCommand = (data) => !!data.initializer.command;
-const isDeno = ({ packageManager }) => packageManager === "deno";
-const joinDir = (dir) => ([filename, content]) => [join(dir, ...filename.split("/")), content];
-/**
-* Stringify an object into a valid `.env` file format.
-* From `@std/dotenv/stringify`.
-*
-* @example Usage
-* ```ts
-* import { stringifyEnvs } from "./utils.ts";
-* import { assertEquals } from "@std/assert";
-*
-* const object = { GREETING: "hello world" };
-* assertEquals(stringifyEnvs(object), "GREETING='hello world'");
-* ```
-*
-* @param object object to be stringified
-* @returns string of object
-*/
-function stringifyEnvs(object) {
-	const lines = [];
-	for (const [key, value] of Object.entries(object)) {
-		let quote;
-		let escapedValue = value ?? "";
-		if (key.startsWith("#")) {
-			console.warn(`key starts with a '#' indicates a comment and is ignored: '${key}'`);
-			continue;
-		} else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
-			escapedValue = escapedValue.replaceAll("\n", "\\n");
-			quote = `"`;
-		} else if (escapedValue.match(/\W/)) quote = "'";
-		if (quote) {
-			escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
-			escapedValue = `${quote}${escapedValue}${quote}`;
-		}
-		const line = `${key}=${escapedValue}`;
-		lines.push(line);
-	}
-	return lines.join("\n");
-}
-
-//#endregion
-export { hasCommand, isDeno, isDry, joinDir, stringifyEnvs };

package/dist/init/ask/dir.js

@@ -1,82 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { getCwd, getOsType, runSubCommand } from "../../utils.js";
-import { isDirectoryEmpty, logger } from "../lib.js";
-import { printError } from "@optique/run";
-import { message } from "@optique/core/message";
-import { identity, pipe, when } from "@fxts/core";
-import { input } from "@inquirer/prompts";
-import toggle from "inquirer-toggle";
-
-//#region src/init/ask/dir.ts
-/**
-* Fills in the project directory by prompting the user if not provided.
-* If the directory is not empty, asks the user whether to use it anyway.
-* If the user agrees, offers to move existing contents to trash.
-* Else, recursively prompts for a new directory until a valid one is provided.
-*
-* @param options - Initialization options possibly containing a directory
-* @returns A promise resolving to options with a guaranteed directory
-*/
-const fillDir = async (options) => {
-	const dir = options.dir ?? await askDir(getCwd());
-	return await askIfNonEmpty(dir) ? {
-		...options,
-		dir
-	} : await fillDir(options);
-};
-var dir_default = fillDir;
-const askDir = (cwd) => input({
-	message: "Project directory:",
-	default: cwd
-});
-const askIfNonEmpty = async (dir) => {
-	if (await isDirectoryEmpty(dir)) return true;
-	if (await askNonEmpty(dir)) return await moveDirToTrash(dir);
-	return false;
-};
-const askNonEmpty = (dir) => toggle.default({
-	message: `Directory "${dir}" is not empty.
-Do you want to use it anyway?`,
-	default: false
-});
-const moveDirToTrash = (dir) => pipe(dir, askMoveToTrash, when(identity, moveToTrash(dir)));
-const askMoveToTrash = (dir) => toggle.default({
-	message: `Do you want to move the contents of "${dir}" to the trash?
-If you choose "No", you should choose another directory.`,
-	default: false
-});
-const moveToTrash = (dir) => () => pipe(getOsType(), getTrashCommand, (fn) => fn(dir), (cmd) => runSubCommand(cmd, { stdio: "ignore" }), () => true).catch((e) => {
-	logger.error(e);
-	printError(message`Failed to move ${dir} to trash.
-Please move it manually.`);
-	return false;
-});
-const getTrashCommand = (os) => trashCommands[os] ?? trashCommands.linux;
-const trashCommands = {
-	darwin: (dir) => ["trash", dir],
-	win32: (dir) => [
-		"powershell",
-		"-Command",
-		getPowershellTrashCommand(dir)
-	],
-	linux: (dir) => [
-		"rm",
-		"-rf",
-		dir
-	]
-};
-const getPowershellTrashCommand = (dir) => [
-	"Add-Type",
-	"-AssemblyName",
-	"Microsoft.VisualBasic;",
-	"[Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory('",
-	dir,
-	"',",
-	"'OnlyErrorDialogs',",
-	"'SendToRecycleBin')"
-].join(" ");
-
-//#endregion
-export { dir_default as default };