@reliverse/build 2.2.7

package/dist/impl/dts-generator.js

@@ -0,0 +1,514 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { logger } from "@reliverse/relinka";
+import { readTSConfig } from "@reliverse/typerso";
+import { getDeclarations } from "./providers/mkdist-dts.js";
+export async function generateDeclarations(options) {
+  const { package: pkg, dtsOptions, format = "esm", outputDir } = options;
+  try {
+    if (dtsOptions.enable === false) {
+      return { success: true };
+    }
+    const dtsOutputDir = resolveDtsOutputDir(pkg, dtsOptions, outputDir);
+    if (!existsSync(dtsOutputDir)) {
+      mkdirSync(dtsOutputDir, { recursive: true });
+    }
+    const tsconfig = await readTSConfig(pkg.path);
+    if (!tsconfig) {
+      return {
+        success: false,
+        error: "No tsconfig.json found"
+      };
+    }
+    const enforcedOptions = enforceDeclarationOptions(
+      tsconfig,
+      dtsOptions,
+      format
+    );
+    const provider = dtsOptions.provider || "dts-bundle-generator";
+    switch (provider) {
+      case "dts-bundle-generator":
+        return await generateWithDtsBundleGenerator(
+          pkg,
+          dtsOptions,
+          dtsOutputDir,
+          enforcedOptions
+        );
+      case "api-extractor":
+        return await generateBundledDeclarations(
+          pkg,
+          dtsOptions,
+          dtsOutputDir,
+          enforcedOptions
+        );
+      case "typescript":
+        return await generateBundlelessDeclarations(
+          pkg,
+          dtsOptions,
+          dtsOutputDir,
+          enforcedOptions
+        );
+      case "mkdist":
+        return await generateWithMkdist(
+          pkg,
+          dtsOptions,
+          dtsOutputDir,
+          enforcedOptions
+        );
+      default:
+        if (dtsOptions.bundle) {
+          return await generateBundledDeclarations(
+            pkg,
+            dtsOptions,
+            dtsOutputDir,
+            enforcedOptions
+          );
+        } else {
+          return await generateBundlelessDeclarations(
+            pkg,
+            dtsOptions,
+            dtsOutputDir,
+            enforcedOptions
+          );
+        }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (dtsOptions.abortOnError !== false) {
+      return {
+        success: false,
+        error: errorMessage
+      };
+    } else {
+      logger.warn(`\u26A0\uFE0F  Declaration generation failed for ${pkg.name}:`);
+      logger.warn(`  Error: ${errorMessage}`);
+      logger.warn(
+        `  Provider: ${dtsOptions.provider || "dts-bundle-generator"}`
+      );
+      logger.warn(`  Output directory: ${outputDir}`);
+      return { success: true };
+    }
+  }
+}
+function resolveDtsOutputDir(pkg, dtsOptions, buildOutputDir) {
+  if (dtsOptions.distPath) {
+    return resolve(pkg.path, dtsOptions.distPath);
+  }
+  try {
+    const tsconfig = readFileSync(join(pkg.path, "tsconfig.json"), "utf-8");
+    const parsed = JSON.parse(tsconfig);
+    if (parsed.compilerOptions?.declarationDir) {
+      return resolve(pkg.path, parsed.compilerOptions.declarationDir);
+    }
+  } catch {
+  }
+  return buildOutputDir;
+}
+function enforceDeclarationOptions(tsconfig, dtsOptions, format) {
+  const enforced = {
+    ...tsconfig,
+    compilerOptions: {
+      ...tsconfig.compilerOptions,
+      // Required options for declaration generation
+      noEmit: false,
+      declaration: true,
+      emitDeclarationOnly: true
+    }
+  };
+  if (dtsOptions.bundle !== true) {
+    enforced.compilerOptions.declarationMap = true;
+  }
+  if (dtsOptions.autoExtension !== false) {
+    switch (format) {
+      case "cjs":
+        enforced.compilerOptions.declarationDir = enforced.compilerOptions.declarationDir || "dist";
+        break;
+      case "esm":
+        enforced.compilerOptions.declarationDir = enforced.compilerOptions.declarationDir || "dist";
+        break;
+      default:
+        enforced.compilerOptions.declarationDir = enforced.compilerOptions.declarationDir || "dist";
+    }
+  }
+  return enforced;
+}
+async function generateBundlelessDeclarations(pkg, _dtsOptions, outputDir, tsconfig) {
+  try {
+    const ts = await import("typescript");
+    const program = ts.createProgram(
+      pkg.entryPoints.filter(
+        (ep) => ep.endsWith(".ts") && !ep.endsWith(".d.ts")
+      ),
+      {
+        ...tsconfig.compilerOptions,
+        outDir: outputDir
+      }
+    );
+    const emitResult = program.emit(void 0, void 0, void 0, true);
+    if (emitResult.diagnostics.length > 0) {
+      const errors = emitResult.diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Error).map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"));
+      if (errors.length > 0) {
+        return {
+          success: false,
+          error: `TypeScript compilation errors:
+${errors.join("\n")}`
+        };
+      }
+    }
+    const generatedFiles = getGeneratedDeclarationFiles(outputDir);
+    logger.info(
+      `\u2705 Generated ${generatedFiles.length} declaration files for ${pkg.name}`
+    );
+    return {
+      success: true,
+      outputDir,
+      files: generatedFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Bundleless declaration generation failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function generateBundledDeclarations(pkg, dtsOptions, outputDir, tsconfig) {
+  try {
+    let apiExtractor;
+    try {
+      apiExtractor = await import("@microsoft/api-extractor");
+    } catch {
+      return {
+        success: false,
+        error: "API Extractor not found. Install @microsoft/api-extractor for bundled declarations."
+      };
+    }
+    const bundlelessResult = await generateBundlelessDeclarations(
+      pkg,
+      dtsOptions,
+      outputDir,
+      tsconfig
+    );
+    if (!bundlelessResult.success) {
+      return bundlelessResult;
+    }
+    const apiExtractorConfig = createApiExtractorConfig(pkg, outputDir);
+    const extractorConfig = apiExtractor.ExtractorConfig.loadFileAndPrepare(apiExtractorConfig);
+    const extractorResult = apiExtractor.Extractor.invoke(extractorConfig, {
+      localBuild: true,
+      showVerboseMessages: false
+    });
+    if (!extractorResult.succeeded) {
+      return {
+        success: false,
+        error: "API Extractor failed to bundle declarations"
+      };
+    }
+    logger.info(`\u2705 Generated bundled declaration file for ${pkg.name}`);
+    return {
+      success: true,
+      outputDir,
+      files: [join(outputDir, `${pkg.name.split("/").pop() || "index"}.d.ts`)]
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Bundled declaration generation failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function createApiExtractorConfig(pkg, outputDir) {
+  const configPath = join(pkg.path, "api-extractor.json");
+  const config = {
+    $schema: "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+    mainEntryPointFilePath: join(outputDir, "index.d.ts"),
+    bundledPackages: [],
+    compiler: {
+      tsconfigFilePath: join(pkg.path, "tsconfig.json")
+    },
+    apiReport: {
+      enabled: false
+    },
+    docModel: {
+      enabled: false
+    },
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: join(
+        outputDir,
+        `${pkg.name.split("/").pop() || "index"}.d.ts`
+      )
+    },
+    tsdocMetadata: {
+      enabled: false
+    }
+  };
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+}
+function getGeneratedDeclarationFiles(outputDir) {
+  const files = [];
+  function scanDirectory(dir) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.name.endsWith(".d.ts")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  scanDirectory(outputDir);
+  return files;
+}
+async function generateWithDtsBundleGenerator(pkg, dtsOptions, outputDir, _tsconfig) {
+  try {
+    let dtsBundleGenerator;
+    try {
+      dtsBundleGenerator = await import("dts-bundle-generator");
+    } catch {
+      return {
+        success: false,
+        error: "dts-bundle-generator not found. Install dts-bundle-generator for this provider."
+      };
+    }
+    const tsconfig = await readTSConfig(pkg.path);
+    if (!tsconfig) {
+      return {
+        success: false,
+        error: "No tsconfig.json found"
+      };
+    }
+    const entryPoints = pkg.entryPoints.filter((ep) => ep.endsWith(".ts") && !ep.endsWith(".d.ts")).map((filePath) => ({
+      filePath
+    }));
+    if (entryPoints.length === 0) {
+      return {
+        success: false,
+        error: "No valid TypeScript entry points found"
+      };
+    }
+    const config = {
+      preferredConfigPath: dtsOptions.dtsBundleGenerator?.preferredConfigPath || join(pkg.path, "tsconfig.json"),
+      ...dtsOptions.dtsBundleGenerator
+    };
+    const result = dtsBundleGenerator.generateDtsBundle(entryPoints, config);
+    const generatedFiles = [];
+    for (let i = 0; i < entryPoints.length; i++) {
+      const entryPoint = entryPoints[i];
+      const content = result[i];
+      if (!entryPoint || !content) {
+        logger.warn(`\u26A0\uFE0F  No declaration content generated for entry point ${i}`);
+        continue;
+      }
+      let relativePath = entryPoint.filePath.replace(`${pkg.path}/`, "").replace(`${pkg.path}\\`, "");
+      if (relativePath.startsWith("src/") || relativePath.startsWith("src\\")) {
+        relativePath = relativePath.substring(4);
+      }
+      const destPath = join(outputDir, relativePath).replace(/\.ts$/, ".d.ts");
+      const destDir = join(destPath, "..");
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+      }
+      writeFileSync(destPath, content);
+      generatedFiles.push(destPath);
+      logger.info(
+        `\u2705 Generated declaration file: ${destPath} (${content.length} bytes)`
+      );
+    }
+    if (generatedFiles.length === 0) {
+      return {
+        success: false,
+        error: "No declaration files were generated"
+      };
+    }
+    logger.info(
+      `\u2705 Generated ${generatedFiles.length} declaration files for ${pkg.name} using dts-bundle-generator`
+    );
+    return {
+      success: true,
+      outputDir,
+      files: generatedFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `dts-bundle-generator failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function generateWithMkdist(pkg, dtsOptions, outputDir, _tsconfig) {
+  try {
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    const vfs = /* @__PURE__ */ new Map();
+    const readErrors = [];
+    for (const entryPoint of pkg.entryPoints) {
+      if (entryPoint.endsWith(".ts") && !entryPoint.endsWith(".d.ts")) {
+        try {
+          const content = readFileSync(entryPoint, "utf-8");
+          const hasExports = /export\s+(?:default\s+)?(?:function|class|interface|type|const|let|var|enum|namespace|\*|\{[^}]*\})/m.test(
+            content
+          );
+          if (!hasExports) {
+            logger.warn(
+              `\u26A0\uFE0F  Entry point ${entryPoint} appears to have no exports - this may cause declaration generation to fail`
+            );
+          }
+          vfs.set(entryPoint, content);
+        } catch (error) {
+          const errorMsg = `Failed to read entry point ${entryPoint}: ${error instanceof Error ? error.message : String(error)}`;
+          readErrors.push(errorMsg);
+          logger.warn(`\u26A0\uFE0F  ${errorMsg}`);
+        }
+      }
+    }
+    if (vfs.size === 0) {
+      return {
+        success: false,
+        error: "No valid TypeScript entry points found for mkdist provider"
+      };
+    }
+    const mkdistOptions = dtsOptions.mkdist || {};
+    const declarations = await getDeclarations(
+      vfs,
+      pkg,
+      dtsOptions,
+      outputDir,
+      mkdistOptions
+    );
+    const generatedFiles = [];
+    let hasErrors = false;
+    for (const [filename, result] of Object.entries(declarations)) {
+      if (!result.contents) {
+        continue;
+      }
+      const destPath = filename.replace(/\.ts$/, ".d.ts");
+      const destDir = join(destPath, "..");
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+      }
+      try {
+        writeFileSync(destPath, result.contents);
+        generatedFiles.push(destPath);
+      } catch (error) {
+        logger.error(
+          `Failed to write declaration file ${destPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        hasErrors = true;
+      }
+      if (result.errors && result.errors.length > 0) {
+        hasErrors = true;
+        for (const error of result.errors) {
+          logger.warn(`\u26A0\uFE0F  Declaration error in ${filename}: ${error.message}`);
+        }
+      }
+      logger.info(
+        `\u2705 Generated declaration file: ${destPath} (${result.contents.length} bytes)`
+      );
+    }
+    if (generatedFiles.length === 0) {
+      const diagnosticInfo = [];
+      if (vfs.size === 0) {
+        diagnosticInfo.push("No TypeScript files found in entry points");
+        if (readErrors.length > 0) {
+          diagnosticInfo.push(`File read errors: ${readErrors.length}`);
+          diagnosticInfo.push(...readErrors.map((error) => `  - ${error}`));
+        }
+      } else {
+        diagnosticInfo.push(`Found ${vfs.size} TypeScript files in VFS`);
+        if (readErrors.length > 0) {
+          diagnosticInfo.push(`File read errors: ${readErrors.length}`);
+          diagnosticInfo.push(...readErrors.map((error) => `  - ${error}`));
+        }
+      }
+      const declarationFiles = Array.from(vfs.keys()).filter(
+        (key) => key.endsWith(".d.ts")
+      );
+      if (declarationFiles.length > 0) {
+        diagnosticInfo.push(
+          `Generated ${declarationFiles.length} declaration files in VFS but failed to write them`
+        );
+        diagnosticInfo.push(
+          `Declaration files: ${declarationFiles.join(", ")}`
+        );
+      } else {
+        diagnosticInfo.push("No declaration files were generated in VFS");
+      }
+      const hasCompilationErrors = Object.values(declarations).some(
+        (result) => result.errors && result.errors.length > 0
+      );
+      if (hasCompilationErrors) {
+        diagnosticInfo.push("TypeScript compilation errors detected");
+      }
+      const validEntryPoints = pkg.entryPoints.filter(
+        (ep) => ep.endsWith(".ts") && !ep.endsWith(".d.ts")
+      );
+      diagnosticInfo.push(`Entry points processed: ${validEntryPoints.length}`);
+      if (validEntryPoints.length > 0) {
+        diagnosticInfo.push(`Entry points: ${validEntryPoints.join(", ")}`);
+      }
+      const errorMessage = [
+        "No declaration files were generated by mkdist provider",
+        "",
+        "Diagnostic information:",
+        ...diagnosticInfo.map((info) => `  \u2022 ${info}`),
+        "",
+        "Troubleshooting suggestions:",
+        "  \u2022 Ensure your TypeScript files have proper exports",
+        "  \u2022 Check for TypeScript compilation errors in your source files",
+        "  \u2022 Verify that your tsconfig.json has 'declaration: true'",
+        "  \u2022 Try using a different DTS provider (e.g., 'typescript' or 'dts-bundle-generator')",
+        "  \u2022 Check if your entry points contain valid TypeScript code"
+      ].join("\n");
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+    if (hasErrors) {
+      logger.warn(
+        `\u26A0\uFE0F  mkdist generated ${generatedFiles.length} declaration files with some errors`
+      );
+    } else {
+      logger.info(
+        `\u2705 Generated ${generatedFiles.length} declaration files for ${pkg.name} using mkdist provider`
+      );
+    }
+    return {
+      success: true,
+      outputDir,
+      files: generatedFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `mkdist declaration generation failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+export async function generateWithTsgo(pkg, dtsOptions, outputDir) {
+  try {
+    logger.warn(
+      "\u26A0\uFE0F  tsgo support is experimental and not yet implemented, falling back to TypeScript Compiler API"
+    );
+    return await generateBundlelessDeclarations(pkg, dtsOptions, outputDir, {
+      compilerOptions: {}
+    });
+  } catch (error) {
+    return {
+      success: false,
+      error: `tsgo declaration generation failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}

package/dist/impl/go-build.d.ts

@@ -0,0 +1,10 @@
+import type { GoBuildOptions } from "@reliverse/config/impl/build";
+interface GoBuildResult {
+    success: boolean;
+    errors: string[];
+}
+/**
+ * Build Go binaries for a package
+ */
+export declare function buildGo(packagePath: string, packageName: string, config?: GoBuildOptions): Promise<GoBuildResult>;
+export {};