@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/utils/utils-fs.js

@@ -0,0 +1,183 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import pMap from "p-map";
+import { glob } from "tinyglobby";
+import { CONCURRENCY_DEFAULT, SHOW_VERBOSE } from "../config/constants.js";
+import { determineDistName } from "./utils-determine.js";
+export async function copyRootFile(outDirRoot, fileNames) {
+  if (fileNames.length === 0) {
+    return;
+  }
+  const EXCLUDED_FILES = ["bin", "jsr.json", "jsr.jsonc", "package.json"];
+  try {
+    await fs.ensureDir(outDirRoot);
+    const specialFileHandlers = {
+      LICENSE: {
+        variants: ["LICENSE", "LICENSE.md", "LICENSES"]
+      },
+      README: {
+        variants: ["README.md", "README"]
+      }
+    };
+    await pMap(
+      fileNames,
+      async (fileName) => {
+        try {
+          if (EXCLUDED_FILES.includes(fileName)) {
+            relinka(
+              "verbose",
+              `The following artifact is auto-generated in dist and will not be copied from the root: ${fileName}`
+            );
+            return;
+          }
+          const specialConfig = specialFileHandlers[fileName];
+          if (specialConfig?.variants) {
+            for (const variant of specialConfig.variants) {
+              const file = await findFileCaseInsensitive(variant);
+              if (file) {
+                const targetPath = path.join(outDirRoot, variant);
+                if (await fs.pathExists(targetPath)) {
+                  await fs.remove(targetPath);
+                }
+                await fs.copy(file, targetPath, { errorOnExist: true });
+                relinka("verbose", `Copied ${file} to ${outDirRoot}/${variant}`);
+              }
+            }
+          } else {
+            const file = await findFileCaseInsensitive(fileName);
+            if (file) {
+              const targetPath = path.join(outDirRoot, fileName);
+              if (await fs.pathExists(targetPath)) {
+                await fs.remove(targetPath);
+              }
+              await fs.copy(file, targetPath, { errorOnExist: true });
+              relinka("verbose", `Copied ${file} to ${outDirRoot}/${fileName}`);
+            }
+          }
+        } catch (fileError) {
+          relinka("error", `Failed to copy ${fileName}: ${fileError}`);
+        }
+      },
+      { concurrency: CONCURRENCY_DEFAULT }
+      // Process up to CONCURRENCY_DEFAULT files simultaneously
+    );
+  } catch (error) {
+    relinka("error", `Failed to copy files: ${error}`);
+    throw new Error(`File copying failed: ${error}`);
+  }
+}
+export async function getDirectorySize(outDirRoot, isDev) {
+  if (SHOW_VERBOSE.getDirectorySize) {
+    relinka("verbose", `Calculating directory size for: ${outDirRoot}`);
+  }
+  try {
+    const files = await fs.readdir(outDirRoot);
+    const sizes = await pMap(
+      files,
+      async (file) => {
+        const fp = path.join(outDirRoot, file);
+        const stats = await fs.stat(fp);
+        return stats.isDirectory() ? getDirectorySize(fp, isDev) : stats.size;
+      },
+      { concurrency: CONCURRENCY_DEFAULT }
+    );
+    const totalSize = sizes.reduce((total, s) => total + s, 0);
+    if (SHOW_VERBOSE.getDirectorySize) {
+      relinka("verbose", `Calculated directory size: ${totalSize} bytes for ${outDirRoot}`);
+    }
+    return totalSize;
+  } catch (error) {
+    relinka("error", `Failed to calculate directory size for ${outDirRoot}`, error);
+    return 0;
+  }
+}
+export async function outDirBinFilesCount(outDirBin) {
+  relinka("verbose", `Counting files in directory: ${outDirBin}`);
+  let fileCount = 0;
+  if (!await fs.pathExists(outDirBin)) {
+    relinka("error", `[outDirBinFilesCount] Directory does not exist: ${outDirBin}`);
+    return fileCount;
+  }
+  await fs.dive(outDirBin, () => {
+    fileCount++;
+  });
+  relinka("verbose", `Total file count in ${outDirBin}: ${fileCount}`);
+  return fileCount;
+}
+async function findFileCaseInsensitive(transpileTargetFile) {
+  const files = await fs.readdir(".");
+  const found = files.find((file) => file.toLowerCase() === transpileTargetFile.toLowerCase());
+  return found || null;
+}
+const TEST_FILE_PATTERNS = [
+  "**/*.test.js",
+  "**/*.test.ts",
+  "**/*.test.d.ts",
+  "**/*-temp.js",
+  "**/*-temp.ts",
+  "**/*-temp.d.ts",
+  "**/__snapshots__/**"
+];
+export async function deleteSpecificFiles(outDirBin) {
+  relinka("verbose", `Deleting test and temporary files in: ${outDirBin}`);
+  const files = await glob(TEST_FILE_PATTERNS, {
+    absolute: true,
+    cwd: outDirBin
+  });
+  const snapshotDirs = await glob("**/__snapshots__", {
+    absolute: true,
+    cwd: outDirBin,
+    onlyDirectories: true
+  });
+  const filesToDelete = files.filter((file) => {
+    if (file.endsWith(".d.ts")) {
+      return file.includes(".test.d.ts") || file.includes("-temp.d.ts");
+    }
+    return true;
+  });
+  if (filesToDelete.length > 0) {
+    await pMap(filesToDelete, async (file) => fs.remove(file), {
+      concurrency: CONCURRENCY_DEFAULT
+    });
+    relinka("verbose", `Deleted files:
+${filesToDelete.join("\n")}`);
+  }
+  if (snapshotDirs.length > 0) {
+    await pMap(snapshotDirs, async (dir) => fs.remove(dir), {
+      concurrency: CONCURRENCY_DEFAULT
+    });
+    relinka("verbose", `Deleted snapshot directories:
+${snapshotDirs.join("\n")}`);
+  }
+}
+export async function readFileSafe(filePath, isJsr, reason) {
+  const distName = determineDistName(filePath, isJsr, void 0);
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    if (SHOW_VERBOSE.readFileSafe) {
+      relinka("verbose", `[${distName}] Successfully read file: ${filePath} [Reason: ${reason}]`);
+    }
+    return content;
+  } catch (error) {
+    relinka("error", `[${distName}] Failed to read file: ${filePath} [Reason: ${reason}]`, error);
+    throw error;
+  }
+}
+export async function writeFileSafe(filePath, content, reason) {
+  try {
+    await fs.writeFile(filePath, content, "utf8");
+    relinka("verbose", `Successfully wrote file: ${filePath} [Reason: ${reason}]`);
+  } catch (error) {
+    relinka("error", `Failed to write file: ${filePath} [Reason: ${reason}]`, error);
+    throw error;
+  }
+}
+export async function validateDirectory(dir) {
+  try {
+    const stat = await fs.stat(dir);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}

package/bin/app/utils/utils-jsr-json.d.ts

@@ -0,0 +1,9 @@
+import type { DlerConfig, LibConfig } from "../types/mod.js";
+/**
+ * Generates a jsr.json configuration file for JSR distributions.
+ */
+export declare function createJsrJSON(outDirRoot: string, isLib: boolean, libsList: Record<string, LibConfig>, config: DlerConfig, libName?: string, pkgDescription?: string): Promise<void>;
+/**
+ * Renames .tsx files by replacing the .tsx extension with -tsx.txt.
+ */
+export declare function renameTsxFiles(dir: string): Promise<void>;

package/bin/app/utils/utils-jsr-json.js

@@ -0,0 +1,75 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import pMap from "p-map";
+import { readPackageJSON } from "pkg-types";
+import { glob } from "tinyglobby";
+import { CONCURRENCY_DEFAULT, cliDomainDocs } from "../config/constants.js";
+export async function createJsrJSON(outDirRoot, isLib, libsList, config, libName = "unknown-lib-name", pkgDescription = "unknown-lib-description") {
+  relinka("verbose", `Creating jsr.json configuration (isLib: ${isLib})`);
+  const originalPkg = await readPackageJSON();
+  let { description, name } = originalPkg;
+  const { author, license, version } = originalPkg;
+  if (isLib) {
+    name = libName;
+    description = pkgDescription;
+    if (!libsList[libName]?.libMainFile) {
+      throw new Error(`libsList.${libName}.libMainFile is not defined for library ${libName}`);
+    }
+  }
+  const pkgHomepage = cliDomainDocs;
+  const jsrConfig = {
+    author,
+    description,
+    exports: isLib && libsList[libName]?.libMainFile ? `./bin/${path.basename(libsList[libName].libMainFile)}` : `./bin/${config.coreEntryFile}`,
+    homepage: pkgHomepage,
+    license: license || "MIT",
+    name,
+    publish: {
+      exclude: ["!.", "node_modules/**", ".env"]
+    },
+    version
+  };
+  const jsrArtifacts = isLib ? config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr : config.publishArtifacts?.["dist-jsr"] || ["jsr.json"];
+  const jsrConfigExt = jsrArtifacts?.find((artifact) => artifact.startsWith("jsr.json"))?.split(".").pop() || "json";
+  const jsrConfigPath = path.join(outDirRoot, `jsr.${jsrConfigExt}`);
+  await fs.writeJSON(jsrConfigPath, jsrConfig, {
+    spaces: 2
+  });
+  relinka("verbose", `Generated jsr.${jsrConfigExt} file in ${outDirRoot}/jsr.${jsrConfigExt}`);
+}
+export async function renameTsxFiles(dir) {
+  relinka("verbose", `Renaming .tsx files in directory: ${dir}`);
+  const files = await glob(["**/*.tsx"], {
+    absolute: true,
+    cwd: dir
+  });
+  const processedPaths = /* @__PURE__ */ new Set();
+  await pMap(
+    files,
+    async (filePath) => {
+      const newPath = filePath.replace(/\.tsx$/, "-tsx.txt");
+      if (processedPaths.has(newPath)) {
+        throw new Error(`Path conflict detected: ${newPath} would be created multiple times`);
+      }
+      if (await fs.pathExists(newPath)) {
+        throw new Error(`Target file already exists: ${newPath}`);
+      }
+      try {
+        await fs.rename(filePath, newPath);
+        processedPaths.add(newPath);
+        relinka("verbose", `Renamed: ${filePath} -> ${newPath}`);
+        if (await fs.pathExists(filePath)) {
+          throw new Error(`Source file still exists after rename: ${filePath}`);
+        }
+        if (!await fs.pathExists(newPath)) {
+          throw new Error(`Target file not found after rename: ${newPath}`);
+        }
+      } catch (error) {
+        throw new Error(`Failed to rename ${filePath} to ${newPath}: ${error}`);
+      }
+    },
+    { concurrency: CONCURRENCY_DEFAULT }
+  );
+  relinka("verbose", `Completed renaming .tsx files in ${dir}`);
+}

package/bin/app/utils/utils-package-json-libraries.d.ts

@@ -0,0 +1,10 @@
+import type { DlerConfig, LibConfig, NpmOutExt } from "../types/mod.js";
+/**
+ * Creates a package.json for a lib distribution.
+ */
+export declare function library_createPackageJSON(libName: string, npmOutDir: string, jsrOutDir: string, effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined, libsList: Record<string, LibConfig>, config: DlerConfig, unifiedBundlerOutExt: NpmOutExt): Promise<void>;
+/**
+ * Creates a JSR configuration file for a library.
+ */
+declare function library_createJsrConfig(libName: string, pkgJsonDir: string, libsList: Record<string, LibConfig>, config: DlerConfig): Promise<void>;
+export { library_createJsrConfig };

package/bin/app/utils/utils-package-json-regular.d.ts

@@ -0,0 +1,8 @@
+import type { DlerConfig, NpmOutExt } from "../types/mod.js";
+/**
+ * Creates a package.json for the main distribution.
+ */
+export declare function regular_createPackageJSON(outDirRoot: string, isJsr: boolean, coreIsCLI: {
+    enabled: boolean;
+    scripts: Record<string, string>;
+}, unifiedBundlerOutExt: NpmOutExt, config: DlerConfig, coreDescription: string, coreBuildOutDir?: string): Promise<void>;

package/bin/app/utils/utils-package-json-regular.js

@@ -0,0 +1,165 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { definePackageJSON, readPackageJSON } from "pkg-types";
+import { cliDomainDocs } from "../config/constants.js";
+import { filterDeps } from "./utils-deps.js";
+export async function regular_createPackageJSON(outDirRoot, isJsr, coreIsCLI, unifiedBundlerOutExt, config, coreDescription, coreBuildOutDir = "bin") {
+  relinka("verbose", `Generating distribution package.json and tsconfig.json (isJsr=${isJsr})...`);
+  const commonPkg = await regular_createCommonPackageFields(coreIsCLI, coreDescription);
+  const originalPkg = await readPackageJSON();
+  const packageName = originalPkg.name || "";
+  relinka(
+    "verbose",
+    `Package name: "${packageName}", CLI enabled: ${coreIsCLI.enabled}, scripts: ${JSON.stringify(coreIsCLI.scripts)}`
+  );
+  const outDirBin = path.join(outDirRoot, coreBuildOutDir);
+  const outExt = unifiedBundlerOutExt || "js";
+  if (isJsr) {
+    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
+      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
+        name,
+        `${coreBuildOutDir}/${path.basename(script)}`
+      ])
+    ) : void 0;
+    if (coreIsCLI.enabled) {
+      relinka("verbose", `Adding CLI bin entries for JSR: ${JSON.stringify(binEntry)}`);
+    }
+    const jsrPkg = definePackageJSON({
+      ...commonPkg,
+      bin: binEntry,
+      dependencies: await regular_getPkgKeepDeps(originalPkg.dependencies, outDirBin, true, config),
+      devDependencies: await filterDeps(originalPkg.devDependencies, true, outDirBin, true, config),
+      exports: {
+        ".": `./${coreBuildOutDir}/${config.coreEntryFile}`
+      },
+      files: [
+        .../* @__PURE__ */ new Set([
+          coreBuildOutDir,
+          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
+        ])
+      ]
+    });
+    await fs.writeJSON(path.join(outDirRoot, "package.json"), jsrPkg, {
+      spaces: 2
+    });
+    if (coreIsCLI.enabled) {
+      relinka(
+        "verbose",
+        `JSR package.json created with CLI bin entries: ${JSON.stringify(jsrPkg.bin)}`
+      );
+    }
+  } else {
+    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
+      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
+        name,
+        `${coreBuildOutDir}/${path.basename(script).replace(/\.ts$/, `.${outExt}`)}`
+      ])
+    ) : void 0;
+    if (coreIsCLI.enabled) {
+      relinka("verbose", `Adding CLI bin entries for NPM: ${JSON.stringify(binEntry)}`);
+    }
+    const npmPkg = definePackageJSON({
+      ...commonPkg,
+      bin: binEntry,
+      dependencies: await regular_getPkgKeepDeps(
+        originalPkg.dependencies,
+        outDirBin,
+        false,
+        config
+      ),
+      devDependencies: await filterDeps(
+        originalPkg.devDependencies,
+        true,
+        outDirBin,
+        false,
+        config
+      ),
+      exports: {
+        ".": `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`
+      },
+      files: [
+        .../* @__PURE__ */ new Set([
+          coreBuildOutDir,
+          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
+        ])
+      ],
+      main: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
+      module: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
+      publishConfig: { access: "public" }
+    });
+    await fs.writeJSON(path.join(outDirRoot, "package.json"), npmPkg, {
+      spaces: 2
+    });
+    if (coreIsCLI.enabled) {
+      relinka(
+        "verbose",
+        `NPM package.json created with CLI bin entries: ${JSON.stringify(npmPkg.bin)}`
+      );
+    }
+  }
+  relinka("verbose", `Created package.json in ${outDirRoot}`);
+}
+async function regular_createCommonPackageFields(coreIsCLI, coreDescription) {
+  relinka("verbose", "Generating common package fields");
+  const originalPkg = await readPackageJSON();
+  const { author, description, keywords, license, name, version } = originalPkg;
+  relinka("verbose", `Original package name: "${name}", version: "${version}"`);
+  const pkgHomepage = cliDomainDocs;
+  const commonPkg = {
+    dependencies: originalPkg.dependencies || {},
+    description: coreDescription || description,
+    homepage: pkgHomepage,
+    license: license || "MIT",
+    name,
+    type: "module",
+    version
+  };
+  if (coreIsCLI.enabled) {
+    relinka("verbose", "coreIsCLI is enabled, adding CLI-specific fields to common package fields");
+    if (commonPkg.keywords) {
+      const cliKeywords = Object.keys(coreIsCLI.scripts);
+      relinka(
+        "verbose",
+        `Adding CLI keywords to existing keywords: ${JSON.stringify(cliKeywords)}`
+      );
+      commonPkg.keywords = [
+        .../* @__PURE__ */ new Set(["cli", ...cliKeywords, "command-line", ...commonPkg.keywords])
+      ];
+      relinka("verbose", `Updated keywords: ${JSON.stringify(commonPkg.keywords)}`);
+    } else if (name) {
+      const cliKeywords = Object.keys(coreIsCLI.scripts);
+      relinka("verbose", `Setting new CLI keywords: ${JSON.stringify(cliKeywords)}`);
+      commonPkg.keywords = ["cli", "command-line", ...cliKeywords];
+      relinka("verbose", `Set keywords: ${JSON.stringify(commonPkg.keywords)}`);
+    }
+  } else {
+    relinka("verbose", "coreIsCLI is false, skipping CLI-specific fields");
+  }
+  if (author) {
+    const repoOwner = typeof author === "string" ? author : author.name;
+    const repoName = name ? name.startsWith("@") ? name.split("/").pop() || name : name : "";
+    Object.assign(commonPkg, {
+      author,
+      bugs: {
+        email: "blefnk@gmail.com",
+        url: `https://github.com/${repoOwner}/${repoName}/issues`
+      },
+      keywords: [.../* @__PURE__ */ new Set([repoOwner, ...commonPkg.keywords || []])],
+      repository: {
+        type: "git",
+        url: `git+https://github.com/${repoOwner}/${repoName}.git`
+      }
+    });
+  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
+    commonPkg.keywords = keywords;
+  }
+  relinka("verbose", "Common package fields generated");
+  return commonPkg;
+}
+async function regular_getPkgKeepDeps(originalDeps, outDirBin, isJsr, config) {
+  if (!originalDeps) {
+    return {};
+  }
+  return filterDeps(originalDeps, false, outDirBin, isJsr, config);
+}

package/bin/app/utils/utils-perf.d.ts

@@ -0,0 +1,5 @@
+import type { PerfTimer } from "../types/mod.js";
+export declare function createPerfTimer(): PerfTimer;
+export declare function getElapsedPerfTime(timer: PerfTimer): number;
+export declare function pausePerfTimer(timer: PerfTimer): void;
+export declare function resumePerfTimer(timer: PerfTimer): void;

package/bin/app/utils/utils-security.d.ts

@@ -0,0 +1,12 @@
+export declare const setFileSizeLimits: (maxFileSize?: number, maxMergeSize?: number) => void;
+export declare const ALLOWED_FILE_TYPES: Set<string>;
+export declare const validatePath: (filePath: string, baseDir: string) => string;
+export declare const validateFileType: (type: string) => void;
+export declare const validateContent: (content: unknown, type: string) => void;
+export declare const sanitizeInput: (input: string) => string;
+export declare const checkPermissions: (filePath: string, operation: "read" | "write") => Promise<void>;
+export declare const checkFileSize: (filePath: string) => Promise<void>;
+export declare const handleCtxError: (error: unknown, context: string) => never;
+export declare const validateTemplate: (template: any) => void;
+export declare const validateMergeOperation: (files: string[]) => Promise<void>;
+export declare const validateFileExists: (filePath: string, operation: string) => Promise<void>;

package/bin/app/utils/utils-security.js

@@ -0,0 +1,95 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_MERGE_SIZE = DEFAULT_MAX_FILE_SIZE * 10;
+let MAX_FILE_SIZE = DEFAULT_MAX_FILE_SIZE;
+let MAX_MERGE_SIZE = DEFAULT_MAX_MERGE_SIZE;
+export const setFileSizeLimits = (maxFileSize, maxMergeSize) => {
+  if (maxFileSize !== void 0) {
+    MAX_FILE_SIZE = maxFileSize;
+  }
+  if (maxMergeSize !== void 0) {
+    MAX_MERGE_SIZE = maxMergeSize;
+  }
+};
+export const ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set(["text", "json", "binary"]);
+export const validatePath = (filePath, baseDir) => {
+  const normalizedPath = path.normalize(filePath);
+  const normalizedBaseDir = path.normalize(baseDir);
+  const resolvedPath = path.resolve(normalizedBaseDir, normalizedPath);
+  const relativePath = path.relative(normalizedBaseDir, resolvedPath);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    throw new Error(`Path traversal attempt detected: ${filePath}`);
+  }
+  return resolvedPath;
+};
+export const validateFileType = (type) => {
+  if (!ALLOWED_FILE_TYPES.has(type)) {
+    throw new Error(`Invalid file type: ${type}`);
+  }
+};
+export const validateContent = (content, type) => {
+  if (type === "json" && typeof content !== "object") {
+    throw new Error("Invalid JSON content");
+  }
+  if (type === "text" && typeof content !== "string") {
+    throw new Error("Invalid text content");
+  }
+};
+export const sanitizeInput = (input) => {
+  return input.replace(/[<>"|?*]/g, "_");
+};
+export const checkPermissions = async (filePath, operation) => {
+  try {
+    const dir = path.dirname(filePath);
+    if (operation === "write") {
+      await fs.ensureDir(dir);
+      await fs.access(dir, fs.constants.W_OK);
+      return;
+    }
+    if (operation === "read") {
+      if (!await fs.pathExists(filePath)) {
+        throw new Error(`File does not exist: ${filePath}`);
+      }
+      await fs.access(filePath, fs.constants.R_OK);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("does not exist")) {
+      throw error;
+    }
+    throw new Error(`Permission denied: ${operation} access to ${filePath}`);
+  }
+};
+export const checkFileSize = async (filePath) => {
+  const stats = await fs.stat(filePath);
+  if (stats.size > MAX_FILE_SIZE) {
+    throw new Error(`File too large: ${filePath}`);
+  }
+};
+export const handleCtxError = (error, context) => {
+  const message = error instanceof Error ? error.message : String(error);
+  relinka("error", `Error in ${context}: ${message}`);
+  process.exit(1);
+};
+export const validateTemplate = (template) => {
+  if (!template.name || typeof template.name !== "string") {
+    throw new Error("Invalid template name");
+  }
+  if (!template.config?.files || typeof template.config.files !== "object") {
+    throw new Error("Invalid template files configuration");
+  }
+};
+export const validateMergeOperation = async (files) => {
+  const totalSize = await Promise.all(files.map(async (f) => (await fs.stat(f)).size)).then(
+    (sizes) => sizes.reduce((a, b) => a + b, 0)
+  );
+  if (totalSize > MAX_MERGE_SIZE) {
+    throw new Error("Total size of files to merge exceeds limit");
+  }
+};
+export const validateFileExists = async (filePath, operation) => {
+  if (!await fs.pathExists(filePath)) {
+    throw new Error(`File does not exist for ${operation}: ${filePath}`);
+  }
+};

package/bin/app/utils/utils-tsconfig.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a tsconfig.json file for the distribution.
+ */
+export declare function createTSConfig(outDirRoot: string, allowImportingTsExtensions: boolean): Promise<void>;
+/**
+ * Creates a minimal tsconfig file for a new project. If `isDev` is true and
+ * the project path contains "tests-runtime", the file is saved as "tsconfig.txt"
+ * instead of "tsconfig.json".
+ */
+export declare function createProjectTSConfig(projectPath: string, isLib: boolean, isDev: boolean): Promise<void>;

package/bin/app/utils/utils-tsconfig.js

@@ -0,0 +1,81 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineTSConfig, writeTSConfig } from "pkg-types";
+import { tsconfigJson } from "../config/constants.js";
+export async function createTSConfig(outDirRoot, allowImportingTsExtensions) {
+  relinka(
+    "verbose",
+    `Creating tsconfig.json in ${outDirRoot} (allowImportingTsExtensions=${allowImportingTsExtensions})`
+  );
+  const tsConfig = defineTSConfig({
+    compilerOptions: {
+      allowImportingTsExtensions,
+      allowJs: true,
+      esModuleInterop: true,
+      exactOptionalPropertyTypes: false,
+      isolatedModules: true,
+      lib: ["ESNext"],
+      module: "NodeNext",
+      moduleDetection: "force",
+      moduleResolution: "nodenext",
+      noEmit: true,
+      noFallthroughCasesInSwitch: false,
+      noImplicitAny: false,
+      noImplicitOverride: true,
+      noImplicitReturns: false,
+      noUncheckedIndexedAccess: true,
+      noUnusedLocals: false,
+      noUnusedParameters: false,
+      resolveJsonModule: true,
+      skipLibCheck: true,
+      strict: true,
+      strictNullChecks: false,
+      transpileTarget: "ESNext",
+      verbatimModuleSyntax: true
+    },
+    exclude: ["**/node_modules"],
+    include: ["./bin/**/*.ts"]
+  });
+  await fs.writeJSON(path.join(outDirRoot, tsconfigJson), tsConfig, {
+    spaces: 2
+  });
+  relinka("verbose", `Created tsconfig.json in ${outDirRoot}`);
+}
+export async function createProjectTSConfig(projectPath, isLib, isDev) {
+  const tsconfig = defineTSConfig({
+    compilerOptions: {
+      esModuleInterop: true,
+      skipLibCheck: true,
+      target: "es2022",
+      allowJs: true,
+      resolveJsonModule: true,
+      moduleDetection: "force",
+      isolatedModules: true,
+      verbatimModuleSyntax: true,
+      strict: true,
+      noUncheckedIndexedAccess: true,
+      noImplicitOverride: true,
+      ...isLib ? { lib: ["es2022"] } : {
+        module: "preserve",
+        noEmit: true,
+        lib: ["es2022", "dom", "dom.iterable"]
+      }
+    },
+    ...isLib ? { include: ["**/*.ts"] } : { include: ["**/*.ts", "**/*.tsx"] },
+    exclude: ["node_modules"]
+  });
+  const useTxt = isDev && projectPath.includes("tests-runtime");
+  const filename = useTxt ? "tsconfig.txt" : "tsconfig.json";
+  const tsconfigPath = path.join(projectPath, filename);
+  if (useTxt) {
+    const rawContent = JSON.stringify(tsconfig, null, 2);
+    await fs.writeFile(tsconfigPath, rawContent, "utf-8");
+  } else {
+    await writeTSConfig(tsconfigPath, tsconfig);
+    const content = await fs.readFile(tsconfigPath, "utf-8");
+    const formatted = JSON.stringify(JSON.parse(content), null, 2);
+    await fs.writeFile(tsconfigPath, formatted, "utf-8");
+  }
+  relinka("verbose", `Created ${filename} with ${isLib ? "library" : "application"} configuration`);
+}