@reliverse/build 2.2.7

package/dist/impl/providers/mkdist/loader.js

@@ -0,0 +1,26 @@
+import { resolveLoaders } from "./loaders/loaders-mod.js";
+export function createLoader(loaderOptions = {}) {
+  const loaders = resolveLoaders(loaderOptions.loaders);
+  const loadFile = async (input) => {
+    const context = {
+      loadFile,
+      options: loaderOptions
+    };
+    for (const loader of loaders) {
+      const outputs = await loader(input, context);
+      if (outputs?.length) {
+        return outputs;
+      }
+    }
+    return [
+      {
+        path: input.path,
+        srcPath: input.srcPath,
+        raw: true
+      }
+    ];
+  };
+  return {
+    loadFile
+  };
+}

package/dist/impl/providers/mkdist/loaders/js.d.ts

@@ -0,0 +1,2 @@
+import type { Loader } from "../../../types.js";
+export declare const jsLoader: Loader;

package/dist/impl/providers/mkdist/loaders/js.js

@@ -0,0 +1,50 @@
+import { transform } from "esbuild";
+import jiti from "jiti";
+const DECLARATION_RE = /\.d\.[cm]?ts$/;
+const CM_LETTER_RE = /(?<=\.)(c|m)(?=[jt]s$)/;
+const KNOWN_EXT_RE = /\.(c|m)?[jt]sx?$/;
+const TS_EXTS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
+export const jsLoader = async (input, { options }) => {
+  if (!KNOWN_EXT_RE.test(input.path) || DECLARATION_RE.test(input.path)) {
+    return;
+  }
+  const output = [];
+  let contents = await input.getContents();
+  if (options.declaration && !input.srcPath?.match(DECLARATION_RE)) {
+    const cm = input.srcPath?.match(CM_LETTER_RE)?.[0] || "";
+    const extension2 = `.d.${cm}ts`;
+    output.push({
+      contents,
+      srcPath: input.srcPath,
+      path: input.path,
+      extension: extension2,
+      declaration: true
+    });
+  }
+  if (TS_EXTS.has(input.extension)) {
+    contents = await transform(contents, {
+      ...options.esbuild,
+      loader: "ts"
+    }).then((r) => r.code);
+  } else if (input.extension === ".jsx") {
+    contents = await transform(contents, {
+      loader: "jsx",
+      ...options.esbuild
+    }).then((r) => r.code);
+  }
+  const isCjs = options.format === "cjs";
+  if (isCjs) {
+    contents = jiti("").transform({ source: contents, retainLines: false }).replace(/^exports.default = /gm, "module.exports = ").replace(/^var _default = exports.default = /gm, "module.exports = ").replace("module.exports = void 0;", "");
+  }
+  let extension = isCjs ? ".js" : ".mjs";
+  if (options.ext) {
+    extension = options.ext.startsWith(".") ? options.ext : `.${options.ext}`;
+  }
+  output.push({
+    contents,
+    path: input.path,
+    srcPath: input.srcPath,
+    extension
+  });
+  return output;
+};

package/dist/impl/providers/mkdist/loaders/loaders-mod.d.ts

@@ -0,0 +1,9 @@
+import type { Loader } from "../../../types.js";
+declare const loaders: {
+    js: import("../../../types.js").MkdistLoader;
+};
+type LoaderName = keyof typeof loaders;
+export declare const defaultLoaders: LoaderName[];
+export declare function resolveLoader(loader: LoaderName | Loader): import("../../../types.js").MkdistLoader;
+export declare function resolveLoaders(loadersParam?: (LoaderName | Loader)[]): import("../../../types.js").MkdistLoader[];
+export {};

package/dist/impl/providers/mkdist/loaders/loaders-mod.js

@@ -0,0 +1,22 @@
+import { jsLoader } from "./js.js";
+const loaders = {
+  js: jsLoader
+};
+export const defaultLoaders = ["js"];
+export function resolveLoader(loader) {
+  if (typeof loader === "string") {
+    return loaders[loader];
+  }
+  return loader;
+}
+export function resolveLoaders(loadersParam = defaultLoaders) {
+  return loadersParam.map((loaderName) => {
+    const _loader = resolveLoader(loaderName);
+    if (!_loader) {
+      console.warn("Unknown loader:", loaderName);
+    }
+    return _loader;
+  }).filter(
+    (loader) => loader !== null && loader !== void 0
+  );
+}

package/dist/impl/providers/mkdist/make.d.ts

@@ -0,0 +1,11 @@
+import type { MkdistOptions } from "../../types.js";
+export declare function mkdist(options: MkdistOptions): Promise<{
+    result: {
+        errors: {
+            filename: string;
+            errors: TypeError[];
+        }[];
+        writtenFiles: string[];
+    };
+    duration: number;
+}>;

package/dist/impl/providers/mkdist/make.js

@@ -0,0 +1,230 @@
+import fsp from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { logger } from "@reliverse/relinka";
+import defu from "defu";
+import { glob } from "tinyglobby";
+import { createLoader } from "./loader.js";
+import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
+import { copyFileWithStream } from "./utils/fs.js";
+export async function mkdist(options) {
+  const startTime = Date.now();
+  options.rootDir = resolve(process.cwd(), options.rootDir || ".");
+  options.srcDir = resolve(options.rootDir, options.srcDir || "src");
+  options.distDir = resolve(options.rootDir, options.distDir || "dist");
+  if (options.cleanDist !== false) {
+    if (options.verbose) {
+      logger.debug("Cleaning distribution directory...");
+    }
+    await fsp.unlink(options.distDir).catch(() => {
+    });
+    await fsp.rm(options.distDir, { recursive: true, force: true });
+    await fsp.mkdir(options.distDir, { recursive: true });
+  }
+  if (options.verbose) {
+    logger.debug("Scanning input files...");
+  }
+  const filePaths = await glob(options.pattern || "**", {
+    absolute: false,
+    ignore: ["**/node_modules", "**/coverage", "**/.git"],
+    cwd: options.srcDir,
+    dot: true,
+    ...options.globOptions
+  });
+  const files = filePaths.map((path) => {
+    const sourcePath = resolve(options.srcDir, path);
+    return {
+      path,
+      srcPath: sourcePath,
+      extension: extname(path),
+      getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
+    };
+  });
+  if (options.verbose) {
+    logger.debug(`Found ${files.length} files to process`);
+  }
+  options.typescript ||= {};
+  if (options.typescript.compilerOptions) {
+    if (options.verbose) {
+      logger.debug("Normalizing TypeScript compiler options...");
+    }
+    options.typescript.compilerOptions = await normalizeCompilerOptions(
+      options.typescript.compilerOptions
+    );
+  }
+  options.typescript.compilerOptions = defu(
+    { noEmit: false },
+    options.typescript.compilerOptions,
+    {
+      allowJs: true,
+      declaration: true,
+      skipLibCheck: true,
+      strictNullChecks: true,
+      emitDeclarationOnly: true,
+      allowImportingTsExtensions: true,
+      allowNonTsExtensions: true
+    }
+  );
+  if (options.verbose) {
+    logger.debug("Creating file loaders...");
+  }
+  const { loadFile } = createLoader(options);
+  if (options.verbose) {
+    logger.debug("Processing files with loaders...");
+  }
+  const outputs = [];
+  let _processedCount = 0;
+  await Promise.all(
+    files.map(async (file) => {
+      const result = await loadFile(file);
+      if (result) {
+        outputs.push(...result);
+      }
+      _processedCount++;
+    })
+  );
+  if (options.verbose) {
+    logger.debug("Normalizing output extensions...");
+  }
+  const pathConflicts = [];
+  for (const output of outputs.filter((o) => o.extension)) {
+    const renamed = basename(output.path, extname(output.path)) + output.extension;
+    output.path = join(dirname(output.path), renamed);
+    const conflictingOutput = outputs.find(
+      (o) => o !== output && o.path === output.path
+    );
+    if (conflictingOutput) {
+      pathConflicts.push(output.path);
+    }
+  }
+  if (pathConflicts.length > 0) {
+    const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
+    logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
+  if (dtsOutputs.length > 0) {
+    if (options.verbose) {
+      logger.debug(
+        `Generating TypeScript declarations for ${dtsOutputs.length} files...`
+      );
+    }
+    const vfs = /* @__PURE__ */ new Map();
+    for (const output of dtsOutputs) {
+      const originalContent = await fsp.readFile(output.srcPath, {
+        encoding: "utf8"
+      });
+      const normalizedPath = output.srcPath.replace(/\\/g, "/");
+      vfs.set(normalizedPath, originalContent);
+    }
+    const declarations = /* @__PURE__ */ Object.create(null);
+    const getDeclarationsResult = await getDeclarations(vfs, options);
+    Object.assign(declarations, getDeclarationsResult);
+    let _dtsProcessed = 0;
+    for (const output of dtsOutputs) {
+      const normalizedPath = output.srcPath.replace(/\\/g, "/");
+      const result = declarations[normalizedPath];
+      output.contents = result?.contents || "";
+      if (result?.errors) {
+        output.errors = result.errors;
+      }
+      _dtsProcessed++;
+    }
+  }
+  if (options.verbose) {
+    logger.debug("Resolving relative imports...");
+  }
+  const outPaths = new Set(outputs.map((o) => o.path));
+  const resolveId = (from, id = "", resolveExtensions) => {
+    if (!id.startsWith(".")) {
+      return id;
+    }
+    for (const extension of resolveExtensions) {
+      if (outPaths.has(join(dirname(from), id + extension))) {
+        return id + extension;
+      }
+    }
+    return id;
+  };
+  const esmResolveExtensions = [
+    "",
+    "/index.mjs",
+    "/index.js",
+    ".mjs",
+    ".ts",
+    ".js"
+  ];
+  const esmOutputs = outputs.filter(
+    (o) => o.extension === ".mjs" || o.extension === ".js"
+  );
+  for (const output of esmOutputs) {
+    if (output.contents) {
+      output.contents = output.contents.replace(
+        /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
+        (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
+      ).replace(
+        /import\((["'])(.*)(["'])\)/g,
+        (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
+      );
+    }
+  }
+  const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
+  const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
+  for (const output of cjsOutputs) {
+    if (output.contents) {
+      output.contents = output.contents.replace(
+        /require\((["'])(.*)(["'])\)/g,
+        (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
+      );
+    }
+  }
+  const outputsToWrite = outputs.filter((o) => !o.skip);
+  if (options.verbose) {
+    logger.debug(`Writing ${outputsToWrite.length} output files...`);
+  }
+  const writtenFiles = [];
+  const errors = [];
+  let _writtenCount = 0;
+  await Promise.all(
+    outputsToWrite.map(async (output) => {
+      try {
+        const outFile = join(options.distDir, output.path);
+        await fsp.mkdir(dirname(outFile), { recursive: true });
+        await (output.raw ? copyFileWithStream(output.srcPath, outFile) : fsp.writeFile(outFile, output.contents || "", "utf8"));
+        writtenFiles.push(outFile);
+        if (output.errors) {
+          errors.push({ filename: outFile, errors: output.errors });
+        }
+      } catch (error) {
+        const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        errors.push({
+          filename: output.path,
+          errors: [new TypeError(errorMessage)]
+        });
+      }
+      _writtenCount++;
+    })
+  );
+  const duration = Date.now() - startTime;
+  if (errors.length > 0) {
+    logger.warn(`Build completed with ${errors.length} errors`);
+    for (const error of errors.slice(0, 5)) {
+      logger.error(
+        `Error in ${error.filename}: ${error.errors[0]?.message || "Unknown error"}`
+      );
+    }
+    if (errors.length > 5) {
+      logger.error(`... and ${errors.length - 5} more errors`);
+    }
+  } else {
+    if (options.verbose) {
+      logger.debug("Build completed successfully!");
+    }
+  }
+  return {
+    result: {
+      errors,
+      writtenFiles
+    },
+    duration
+  };
+}

package/dist/impl/providers/mkdist/utils/dts.d.ts

@@ -0,0 +1,11 @@
+import type { TSConfig } from "pkg-types";
+import type { CompilerHost, EmitResult } from "typescript";
+import type { MkdistOptions } from "../../../types.js";
+export declare function normalizeCompilerOptions(_options: TSConfig["compilerOptions"]): Promise<any>;
+export type DeclarationOutput = Record<string, {
+    contents: string;
+    errors?: Error[];
+}>;
+export declare function getDeclarations(vfs: Map<string, string>, opts?: Partial<MkdistOptions>): Promise<DeclarationOutput>;
+export declare function extractDeclarations(vfs: Map<string, string>, inputFiles: string[], opts?: Partial<MkdistOptions>): DeclarationOutput;
+export declare function augmentWithDiagnostics(result: EmitResult, output: DeclarationOutput, tsHost: CompilerHost, ts: typeof import("typescript")): void;

package/dist/impl/providers/mkdist/utils/dts.js

@@ -0,0 +1,117 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  findDynamicImports,
+  findExports,
+  findStaticImports,
+  findTypeExports
+} from "mlly";
+export async function normalizeCompilerOptions(_options) {
+  const ts = await import("typescript").then((r) => r.default || r);
+  return ts.convertCompilerOptionsFromJson(_options, process.cwd()).options;
+}
+export async function getDeclarations(vfs, opts) {
+  const ts = await import("typescript").then((r) => r.default || r);
+  const inputFiles = [...vfs.keys()];
+  const tsHost = ts.createCompilerHost(opts?.typescript?.compilerOptions || {});
+  tsHost.writeFile = (fileName, declaration) => {
+    vfs.set(fileName, declaration);
+  };
+  const _readFile = tsHost.readFile;
+  tsHost.readFile = (filename) => {
+    if (vfs.has(filename)) {
+      return vfs.get(filename);
+    }
+    return _readFile(filename);
+  };
+  const program = ts.createProgram(
+    inputFiles,
+    opts?.typescript?.compilerOptions || {},
+    tsHost
+  );
+  const result = program.emit();
+  const output = extractDeclarations(vfs, inputFiles, opts);
+  augmentWithDiagnostics(result, output, tsHost, ts);
+  return output;
+}
+const JS_EXT_RE = /\.(m|c)?(ts|js)$/;
+const JSX_EXT_RE = /\.(m|c)?(ts|js)x?$/;
+const RELATIVE_RE = /^\.{1,2}[/\\]/;
+export function extractDeclarations(vfs, inputFiles, opts) {
+  const output = {};
+  for (const filename of inputFiles) {
+    const dtsFilename = filename.replace(JSX_EXT_RE, ".d.$1$2");
+    const dtsFilenameNormalized = dtsFilename.replace(/\\/g, "/");
+    let contents = vfs.get(dtsFilename) || vfs.get(dtsFilenameNormalized) || "";
+    if (opts?.addRelativeDeclarationExtensions) {
+      const ext = filename.match(JS_EXT_RE)?.[0].replace(/ts$/, "js") || ".js";
+      const imports = findStaticImports(contents);
+      const exports = findExports(contents);
+      const typeExports = findTypeExports(contents);
+      const dynamicImports = findDynamicImports(contents).map(
+        (dynamicImport) => {
+          let specifier;
+          try {
+            const value = JSON.parse(dynamicImport.expression);
+            if (typeof value === "string") {
+              specifier = value;
+            }
+          } catch {
+          }
+          return {
+            code: dynamicImport.code,
+            specifier
+          };
+        }
+      );
+      for (const spec of [
+        ...exports,
+        ...typeExports,
+        ...imports,
+        ...dynamicImports
+      ]) {
+        if (!spec.specifier || !RELATIVE_RE.test(spec.specifier)) {
+          continue;
+        }
+        const srcPath = resolve(filename, "..", spec.specifier);
+        const srcDtsPath = srcPath + ext.replace(JS_EXT_RE, ".d.$1$2");
+        let specifier = spec.specifier;
+        try {
+          if (!vfs.get(srcDtsPath)) {
+            const stat = statSync(srcPath);
+            if (stat.isDirectory()) {
+              specifier += "/index";
+            }
+          }
+        } catch {
+        }
+        contents = contents.replace(
+          spec.code,
+          spec.code.replace(spec.specifier, specifier + ext)
+        );
+      }
+    }
+    output[filename] = { contents };
+    vfs.delete(filename);
+  }
+  return output;
+}
+export function augmentWithDiagnostics(result, output, tsHost, ts) {
+  if (result.diagnostics?.length) {
+    for (const diagnostic of result.diagnostics) {
+      const filename = diagnostic.file?.fileName;
+      if (filename && filename in output && output[filename]) {
+        const entry = output[filename];
+        if (entry) {
+          entry.errors = entry.errors || [];
+          entry.errors.push(
+            new TypeError(ts.formatDiagnostics([diagnostic], tsHost), {
+              cause: diagnostic
+            })
+          );
+        }
+      }
+    }
+    console.error(ts.formatDiagnostics(result.diagnostics, tsHost));
+  }
+}

package/dist/impl/providers/mkdist/utils/fs.d.ts

@@ -0,0 +1 @@
+export declare function copyFileWithStream(sourcePath: string, outPath: string): Promise<unknown>;

package/dist/impl/providers/mkdist/utils/fs.js

@@ -0,0 +1,15 @@
+import { createReadStream, createWriteStream } from "node:fs";
+import { pipeline } from "node:stream";
+export function copyFileWithStream(sourcePath, outPath) {
+  const sourceStream = createReadStream(sourcePath);
+  const outStream = createWriteStream(outPath);
+  return new Promise((resolve, reject) => {
+    pipeline(sourceStream, outStream, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(void 0);
+      }
+    });
+  });
+}

package/dist/impl/providers/mkdist-dts.d.ts

@@ -0,0 +1,24 @@
+import type { DtsOptions } from "@reliverse/config/impl/build";
+import type { TSConfig } from "pkg-types";
+import type { PackageInfo } from "../types.js";
+export interface MkdistDtsOptions {
+    addRelativeDeclarationExtensions?: boolean;
+    pattern?: string;
+    globOptions?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface DeclarationOutput {
+    [filename: string]: {
+        contents: string;
+        errors?: Error[];
+    };
+}
+/**
+ * Generate TypeScript declarations using mkdist's VFS approach
+ * This function bridges the dts-generator.ts expectations with mkdist's internal implementation
+ */
+export declare function getDeclarations(vfs: Map<string, string>, _pkg: PackageInfo, _dtsOptions: DtsOptions, _outputDir: string, mkdistOptions?: MkdistDtsOptions): Promise<DeclarationOutput>;
+/**
+ * Normalize TypeScript compiler options for declaration generation
+ */
+export declare function normalizeCompilerOptions(options: TSConfig["compilerOptions"]): Promise<import("typescript").CompilerOptions>;

package/dist/impl/providers/mkdist-dts.js

@@ -0,0 +1,8 @@
+import { getDeclarations as getMkdistDeclarations } from "./mkdist/utils/dts.js";
+export async function getDeclarations(vfs, _pkg, _dtsOptions, _outputDir, mkdistOptions) {
+  return await getMkdistDeclarations(vfs, mkdistOptions);
+}
+export async function normalizeCompilerOptions(options) {
+  const ts = await import("typescript").then((r) => r.default || r);
+  return ts.convertCompilerOptionsFromJson(options, process.cwd()).options;
+}

package/dist/impl/tsconfig-validator.d.ts

@@ -0,0 +1,35 @@
+import type { PackageInfo } from "./types.js";
+export interface TSConfigValidationResult {
+    valid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export interface TSConfigValidationOptions {
+    /** Whether to make validation errors fatal */
+    strict?: boolean;
+    /** Whether to check for declaration generation compatibility */
+    checkDeclarations?: boolean;
+    /** Whether to check for build output compatibility */
+    checkBuildOutput?: boolean;
+}
+/**
+ * Validate tsconfig.json for common issues and best practices
+ */
+export declare function validateTSConfig(pkg: PackageInfo, options?: TSConfigValidationOptions): Promise<TSConfigValidationResult>;
+/**
+ * Validate tsconfig.json for all packages in a workspace
+ */
+export declare function validateAllTSConfigs(packages: PackageInfo[], options?: TSConfigValidationOptions): Promise<{
+    valid: boolean;
+    results: Array<{
+        package: string;
+        result: TSConfigValidationResult;
+    }>;
+}>;
+/**
+ * Log validation results in a user-friendly format
+ */
+export declare function logValidationResults(results: Array<{
+    package: string;
+    result: TSConfigValidationResult;
+}>, verbose?: boolean): void;