@savvy-web/rslib-builder 0.3.0 → 0.5.0

package/index.js

@@ -3,13 +3,14 @@ import * as __rspack_external_node_path_c5b9b54f from "node:path";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { constants, existsSync, writeFileSync } from "node:fs";
 import { defineConfig } from "@rslib/core";
-import { access, copyFile, mkdir, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { access, copyFile, mkdir, readFile, readdir, rm, stat, unlink as promises_unlink, writeFile } from "node:fs/promises";
 import { logger as core_logger } from "@rsbuild/core";
 import picocolors from "picocolors";
 import { getWorkspaceRoot } from "workspace-tools";
 import { spawn } from "node:child_process";
 import { StandardTags, Standardization, TSDocTagSyntaxKind } from "@microsoft/tsdoc";
-import { createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
+import deep_equal from "deep-equal";
+import typescript, { createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
 import { createRequire } from "node:module";
 import { inspect } from "node:util";
 import sort_package_json from "sort-package-json";
@@ -264,7 +265,7 @@ const AutoEntryPlugin = (options)=>{
         }
     };
 };
-var lib_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig.json","compilerOptions":{"allowSyntheticDefaultImports":true,"composite":true,"declaration":true,"declarationDir":"${configDir}/dist","declarationMap":false,"emitDeclarationOnly":false,"esModuleInterop":true,"explainFiles":false,"forceConsistentCasingInFileNames":true,"incremental":true,"isolatedDeclarations":true,"isolatedModules":true,"jsx":"preserve","lib":["esnext"],"module":"nodenext","moduleResolution":"nodenext","outDir":"${configDir}/dist","resolveJsonModule":true,"rootDir":"${configDir}","skipLibCheck":true,"sourceMap":false,"strict":true,"strictNullChecks":true,"target":"es2023","tsBuildInfoFile":"${configDir}/dist/.tsbuildinfo.lib","typeRoots":["${configDir}/node_modules/@types","${configDir}/types"],"verbatimModuleSyntax":true},"exclude":["${configDir}/node_modules","${configDir}/dist/**/*"],"include":["${configDir}/types/*.ts","${configDir}/package.json","${configDir}/*.ts","${configDir}/*.cts","${configDir}/*.mts","${configDir}/src/**/*.ts","${configDir}/src/**/*.tsx","${configDir}/src/**/*.cts","${configDir}/src/**/*.mts","${configDir}/lib/**/*.ts","${configDir}/lib/**/*.tsx","${configDir}/lib/**/*.cts","${configDir}/lib/**/*.mts","${configDir}/public/**/*.json"]}');
+var lib_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig.json","compilerOptions":{"allowSyntheticDefaultImports":true,"composite":true,"declaration":true,"declarationDir":"${configDir}/dist","declarationMap":false,"emitDeclarationOnly":false,"esModuleInterop":true,"explainFiles":false,"forceConsistentCasingInFileNames":true,"incremental":true,"isolatedDeclarations":false,"isolatedModules":true,"jsx":"preserve","lib":["esnext"],"module":"nodenext","moduleResolution":"nodenext","outDir":"${configDir}/dist","resolveJsonModule":true,"rootDir":"${configDir}","skipLibCheck":true,"sourceMap":false,"strict":true,"strictNullChecks":true,"target":"es2023","tsBuildInfoFile":"${configDir}/dist/.tsbuildinfo.lib","typeRoots":["${configDir}/node_modules/@types","${configDir}/types"],"verbatimModuleSyntax":true},"exclude":["${configDir}/node_modules","${configDir}/dist/**/*"],"include":["${configDir}/types/*.ts","${configDir}/package.json","${configDir}/*.ts","${configDir}/*.cts","${configDir}/*.mts","${configDir}/src/**/*.ts","${configDir}/src/**/*.tsx","${configDir}/src/**/*.cts","${configDir}/src/**/*.mts","${configDir}/lib/**/*.ts","${configDir}/lib/**/*.tsx","${configDir}/lib/**/*.cts","${configDir}/lib/**/*.mts","${configDir}/public/**/*.json"]}');
 const requireCJS = createRequire(import.meta.url);
 const jsonImports = new Map([
     [
@@ -446,7 +447,14 @@ class TsDocConfigBuilder {
         if (tagDefinitions.length > 0) tsdocConfig.tagDefinitions = tagDefinitions;
         if (Object.keys(supportForTags).length > 0) tsdocConfig.supportForTags = supportForTags;
         const configPath = (0, external_node_path_.join)(outputDir, "tsdoc.json");
-        await writeFile(configPath, JSON.stringify(tsdocConfig, null, 2));
+        if (existsSync(configPath)) try {
+            const existingContent = await readFile(configPath, "utf-8");
+            const existingConfig = JSON.parse(existingContent);
+            if (deep_equal(existingConfig, tsdocConfig, {
+                strict: true
+            })) return configPath;
+        } catch  {}
+        await writeFile(configPath, `${JSON.stringify(tsdocConfig, null, "\t")}\n`);
         return configPath;
     }
     static syntaxKindToString(kind) {
@@ -609,13 +617,22 @@ async function bundleDtsFiles(options) {
         });
         if (!extractorResult.succeeded) throw new Error(`API Extractor failed for entry "${entryName}"`);
         if (collectedTsdocWarnings.length > 0) {
+            const isThirdParty = (warning)=>warning.sourceFilePath?.includes("node_modules/") ?? false;
+            const firstPartyWarnings = collectedTsdocWarnings.filter((w)=>!isThirdParty(w));
+            const thirdPartyWarnings = collectedTsdocWarnings.filter(isThirdParty);
             const formatWarning = (warning)=>{
                 const location = warning.sourceFilePath ? `${picocolors.cyan((0, external_node_path_.relative)(cwd, warning.sourceFilePath))}${warning.sourceFileLine ? `:${warning.sourceFileLine}` : ""}${warning.sourceFileColumn ? `:${warning.sourceFileColumn}` : ""}` : null;
                 return location ? `${location}: ${picocolors.yellow(warning.text)}` : picocolors.yellow(warning.text);
             };
-            const warningMessages = collectedTsdocWarnings.map(formatWarning).join("\n  ");
-            if ("fail" === tsdocWarnings) throw new Error(`TSDoc validation failed for entry "${entryName}":\n  ${warningMessages}`);
-            if ("log" === tsdocWarnings) core_logger.warn(`TSDoc warnings for entry "${entryName}":\n  ${warningMessages}`);
+            if (thirdPartyWarnings.length > 0) {
+                const thirdPartyMessages = thirdPartyWarnings.map(formatWarning).join("\n  ");
+                core_logger.warn(`TSDoc warnings from dependencies for entry "${entryName}" (cannot be fixed, bundled types may have documentation issues):\n  ${thirdPartyMessages}`);
+            }
+            if (firstPartyWarnings.length > 0) {
+                const firstPartyMessages = firstPartyWarnings.map(formatWarning).join("\n  ");
+                if ("fail" === tsdocWarnings) throw new Error(`TSDoc validation failed for entry "${entryName}":\n  ${firstPartyMessages}`);
+                if ("log" === tsdocWarnings) core_logger.warn(`TSDoc warnings for entry "${entryName}":\n  ${firstPartyMessages}`);
+            }
         }
         if (generateApiModel && tempApiModelPath) apiModelPath = tempApiModelPath;
         if (generateTsdocMetadata && tempTsdocMetadataPath) tsdocMetadataPath = tempTsdocMetadataPath;
@@ -630,7 +647,7 @@ async function bundleDtsFiles(options) {
     let persistedTsdocConfigPath;
     if (tsdocConfigPath) if (shouldPersist) persistedTsdocConfigPath = tsdocConfigPath;
     else try {
-        await unlink(tsdocConfigPath);
+        await promises_unlink(tsdocConfigPath);
     } catch  {}
     return {
         bundledFiles,
@@ -792,7 +809,7 @@ function runTsgo(options) {
                                 });
                                 await copyFile(file.path, newPath);
                                 log.global.info(`Renamed ${file.relativePath} -> ${originalDtsPath} (from temp api-extractor)`);
-                                await unlink(file.path);
+                                await promises_unlink(file.path);
                             }
                         }
                         allDtsFiles.length = 0;
@@ -1440,6 +1457,413 @@ const PackageJsonTransformPlugin = (options = {})=>{
         }
     };
 };
+class ImportGraph {
+    options;
+    sys;
+    program = null;
+    compilerOptions = null;
+    moduleResolutionCache = null;
+    constructor(options){
+        this.options = options;
+        this.sys = options.sys ?? typescript.sys;
+    }
+    traceFromEntries(entryPaths) {
+        const errors = [];
+        const visited = new Set();
+        const entries = [];
+        const initResult = this.initializeProgram();
+        if (!initResult.success) return {
+            files: [],
+            entries: [],
+            errors: [
+                initResult.error
+            ]
+        };
+        for (const entryPath of entryPaths){
+            const absolutePath = this.resolveEntryPath(entryPath);
+            if (!this.sys.fileExists(absolutePath)) {
+                errors.push({
+                    type: "entry_not_found",
+                    message: `Entry file not found: ${entryPath}`,
+                    path: absolutePath
+                });
+                continue;
+            }
+            entries.push(absolutePath);
+            this.traceImports(absolutePath, visited, errors);
+        }
+        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
+        return {
+            files: files.sort(),
+            entries,
+            errors
+        };
+    }
+    traceFromPackageExports(packageJsonPath) {
+        const absolutePath = this.resolveEntryPath(packageJsonPath);
+        let packageJson;
+        try {
+            const content = this.sys.readFile(absolutePath);
+            if (!content) return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_not_found",
+                        message: `Failed to read package.json: File not found at ${absolutePath}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+            packageJson = JSON.parse(content);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_parse_error",
+                        message: `Failed to parse package.json: ${message}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+        }
+        const extractor = new EntryExtractor();
+        const { entries } = extractor.extract(packageJson);
+        const packageDir = (0, external_node_path_.dirname)(absolutePath);
+        const entryPaths = Object.values(entries).map((p)=>(0, external_node_path_.resolve)(packageDir, p));
+        return this.traceFromEntries(entryPaths);
+    }
+    initializeProgram() {
+        if (this.program) return {
+            success: true
+        };
+        const configPath = this.findTsConfig();
+        if (!configPath) return {
+            success: false,
+            error: {
+                type: "tsconfig_not_found",
+                message: `No tsconfig.json found in ${this.options.rootDir}`,
+                path: this.options.rootDir
+            }
+        };
+        const configFile = typescript.readConfigFile(configPath, (path)=>this.sys.readFile(path));
+        if (configFile.error) {
+            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_read_error",
+                    message: `Failed to read tsconfig.json: ${message}`,
+                    path: configPath
+                }
+            };
+        }
+        const parsed = typescript.parseJsonConfigFileContent(configFile.config, this.sys, (0, external_node_path_.dirname)(configPath));
+        if (parsed.errors.length > 0) {
+            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_parse_error",
+                    message: `Failed to parse tsconfig.json: ${messages}`,
+                    path: configPath
+                }
+            };
+        }
+        this.compilerOptions = parsed.options;
+        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
+        const host = typescript.createCompilerHost(this.compilerOptions, true);
+        host.getCurrentDirectory = ()=>this.options.rootDir;
+        this.program = typescript.createProgram([], this.compilerOptions, host);
+        return {
+            success: true
+        };
+    }
+    findTsConfig() {
+        if (this.options.tsconfigPath) {
+            const customPath = (0, external_node_path_.isAbsolute)(this.options.tsconfigPath) ? this.options.tsconfigPath : (0, external_node_path_.resolve)(this.options.rootDir, this.options.tsconfigPath);
+            if (this.sys.fileExists(customPath)) return customPath;
+            return null;
+        }
+        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>this.sys.fileExists(path));
+        return configPath ?? null;
+    }
+    resolveEntryPath(entryPath) {
+        if ((0, external_node_path_.isAbsolute)(entryPath)) return (0, external_node_path_.normalize)(entryPath);
+        return (0, external_node_path_.normalize)((0, external_node_path_.resolve)(this.options.rootDir, entryPath));
+    }
+    traceImports(filePath, visited, errors) {
+        const normalizedPath = (0, external_node_path_.normalize)(filePath);
+        if (visited.has(normalizedPath)) return;
+        if (this.isExternalModule(normalizedPath)) return;
+        visited.add(normalizedPath);
+        const content = this.sys.readFile(normalizedPath);
+        if (!content) return void errors.push({
+            type: "file_read_error",
+            message: `Failed to read file: ${normalizedPath}`,
+            path: normalizedPath
+        });
+        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
+        const imports = this.extractImports(sourceFile);
+        for (const importPath of imports){
+            const resolved = this.resolveImport(importPath, normalizedPath);
+            if (resolved) this.traceImports(resolved, visited, errors);
+        }
+    }
+    extractImports(sourceFile) {
+        const imports = [];
+        const visit = (node)=>{
+            if (typescript.isImportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isExportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isCallExpression(node)) {
+                const expression = node.expression;
+                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                    const arg = node.arguments[0];
+                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
+                }
+            }
+            typescript.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return imports;
+    }
+    resolveImport(specifier, fromFile) {
+        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
+        }
+        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
+        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, this.sys, this.moduleResolutionCache);
+        if (resolved.resolvedModule) {
+            const resolvedPath = resolved.resolvedModule.resolvedFileName;
+            if (resolved.resolvedModule.isExternalLibraryImport) return null;
+            if (resolvedPath.endsWith(".d.ts")) {
+                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
+                if (this.sys.fileExists(sourcePath)) return sourcePath;
+                return null;
+            }
+            return resolvedPath;
+        }
+        return null;
+    }
+    isExternalModule(filePath) {
+        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+    }
+    isSourceFile(filePath) {
+        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) return false;
+        if (filePath.endsWith(".d.ts")) return false;
+        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
+        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
+        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
+        const excludePatterns = this.options.excludePatterns ?? [];
+        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
+        return true;
+    }
+    static fromEntries(entryPaths, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromEntries(entryPaths);
+    }
+    static fromPackageExports(packageJsonPath, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromPackageExports(packageJsonPath);
+    }
+}
+function formatLintResults(results, cwd) {
+    if (0 === results.messages.length) return "";
+    const lines = [];
+    const messagesByFile = new Map();
+    for (const msg of results.messages){
+        const existing = messagesByFile.get(msg.filePath) ?? [];
+        existing.push(msg);
+        messagesByFile.set(msg.filePath, existing);
+    }
+    for (const [filePath, messages] of messagesByFile){
+        lines.push(picocolors.underline(picocolors.cyan((0, external_node_path_.relative)(cwd, filePath))));
+        for (const msg of messages){
+            const location = picocolors.dim(`${msg.line}:${msg.column}`);
+            const severityColor = 2 === msg.severity ? picocolors.red : picocolors.yellow;
+            const severityLabel = 2 === msg.severity ? "error" : "warning";
+            const rule = msg.ruleId ? picocolors.dim(`(${msg.ruleId})`) : "";
+            lines.push(`  ${location}  ${severityColor(severityLabel)}  ${msg.message} ${rule}`);
+        }
+        lines.push("");
+    }
+    const errorText = 1 === results.errorCount ? "error" : "errors";
+    const warningText = 1 === results.warningCount ? "warning" : "warnings";
+    const summary = results.errorCount > 0 ? picocolors.red(`${results.errorCount} ${errorText}`) : picocolors.yellow(`${results.warningCount} ${warningText}`);
+    lines.push(summary);
+    return lines.join("\n");
+}
+function discoverFilesToLint(options, cwd) {
+    if (options.include && options.include.length > 0) return {
+        files: options.include,
+        errors: [],
+        isGlobPattern: true
+    };
+    const graph = new ImportGraph({
+        rootDir: cwd
+    });
+    const packageJsonPath = (0, external_node_path_.join)(cwd, "package.json");
+    const result = graph.traceFromPackageExports(packageJsonPath);
+    return {
+        files: result.files,
+        errors: result.errors,
+        isGlobPattern: false
+    };
+}
+async function runTsDocLint(options, cwd) {
+    const tsdocOptions = options.tsdoc ?? {};
+    const persistConfig = options.persistConfig;
+    const shouldPersist = TsDocConfigBuilder.shouldPersist(persistConfig);
+    const tsdocConfigOutputPath = TsDocConfigBuilder.getConfigPath(persistConfig, cwd);
+    const tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions, (0, external_node_path_.dirname)(tsdocConfigOutputPath));
+    const eslintModule = await import("eslint");
+    const tsParserModule = await import("@typescript-eslint/parser");
+    const tsdocPluginModule = await import("eslint-plugin-tsdoc");
+    const { ESLint } = eslintModule;
+    const tsParser = tsParserModule.default ?? tsParserModule;
+    const tsdocPlugin = tsdocPluginModule.default ?? tsdocPluginModule;
+    const discovery = discoverFilesToLint(options, cwd);
+    if (0 === discovery.files.length) return {
+        results: {
+            errorCount: 0,
+            warningCount: 0,
+            messages: []
+        },
+        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
+        discoveryErrors: discovery.errors
+    };
+    let eslintConfig;
+    let filesToLint;
+    if (discovery.isGlobPattern) {
+        const includePatterns = discovery.files;
+        filesToLint = includePatterns.filter((p)=>!p.startsWith("!"));
+        eslintConfig = [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**"
+                ]
+            },
+            {
+                files: filesToLint,
+                ignores: includePatterns.filter((p)=>p.startsWith("!")).map((p)=>p.slice(1)),
+                languageOptions: {
+                    parser: tsParser
+                },
+                plugins: {
+                    tsdoc: tsdocPlugin
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ];
+    } else {
+        filesToLint = discovery.files;
+        eslintConfig = [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**"
+                ]
+            },
+            {
+                files: [
+                    "**/*.ts",
+                    "**/*.tsx"
+                ],
+                languageOptions: {
+                    parser: tsParser
+                },
+                plugins: {
+                    tsdoc: tsdocPlugin
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ];
+    }
+    const eslint = new ESLint({
+        cwd,
+        overrideConfigFile: true,
+        overrideConfig: eslintConfig
+    });
+    const eslintResults = await eslint.lintFiles(filesToLint);
+    const messages = [];
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const result of eslintResults)for (const msg of result.messages){
+        messages.push({
+            filePath: result.filePath,
+            line: msg.line,
+            column: msg.column,
+            message: msg.message,
+            ruleId: msg.ruleId,
+            severity: msg.severity
+        });
+        if (2 === msg.severity) errorCount++;
+        else warningCount++;
+    }
+    return {
+        results: {
+            errorCount,
+            warningCount,
+            messages
+        },
+        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
+        discoveryErrors: discovery.errors.length > 0 ? discovery.errors : void 0
+    };
+}
+async function cleanupTsDocConfig(configPath) {
+    if (!configPath) return;
+    try {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(configPath);
+    } catch  {}
+}
+const TsDocLintPlugin = (options = {})=>{
+    const { enabled = true } = options;
+    let tempTsDocConfigPath;
+    return {
+        name: "tsdoc-lint-plugin",
+        setup (api) {
+            if (!enabled) return;
+            api.onBeforeBuild(async ()=>{
+                const cwd = api.context.rootPath;
+                const isCI = TsDocConfigBuilder.isCI();
+                const onError = options.onError ?? (isCI ? "throw" : "error");
+                core_logger.info(`${picocolors.dim("[tsdoc-lint]")} Validating TSDoc comments...`);
+                try {
+                    const { results, tsdocConfigPath, discoveryErrors } = await runTsDocLint(options, cwd);
+                    if (discoveryErrors && discoveryErrors.length > 0) for (const error of discoveryErrors)core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} ${error.message}`);
+                    if (!TsDocConfigBuilder.shouldPersist(options.persistConfig)) tempTsDocConfigPath = tsdocConfigPath;
+                    if (0 === results.errorCount && 0 === results.warningCount) return void core_logger.info(`${picocolors.dim("[tsdoc-lint]")} ${picocolors.green("All TSDoc comments are valid")}`);
+                    const formatted = formatLintResults(results, cwd);
+                    if (results.errorCount > 0) if ("throw" === onError) throw new Error(`TSDoc validation failed:\n${formatted}`);
+                    else if ("error" === onError) core_logger.error(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation errors:\n${formatted}`);
+                    else core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation warnings:\n${formatted}`);
+                    else if (results.warningCount > 0) core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation warnings:\n${formatted}`);
+                } catch (error) {
+                    await cleanupTsDocConfig(tempTsDocConfigPath);
+                    throw error;
+                }
+            });
+            api.onCloseBuild(async ()=>{
+                await cleanupTsDocConfig(tempTsDocConfigPath);
+            });
+        }
+    };
+};
 /* v8 ignore next -- @preserve */ class NodeLibraryBuilder {
     static DEFAULT_OPTIONS = {
         entry: void 0,
@@ -1453,7 +1877,8 @@ const PackageJsonTransformPlugin = (options = {})=>{
         tsconfigPath: void 0,
         externals: [],
         dtsBundledPackages: void 0,
-        transformFiles: void 0
+        transformFiles: void 0,
+        tsdocLint: void 0
     };
     static mergeOptions(options = {}) {
         const merged = {
@@ -1487,6 +1912,11 @@ const PackageJsonTransformPlugin = (options = {})=>{
         const options = NodeLibraryBuilder.mergeOptions(opts);
         const VERSION = await packageJsonVersion();
         const plugins = [];
+        if (options.tsdocLint) {
+            const lintOptions = true === options.tsdocLint ? {} : options.tsdocLint;
+            if (!lintOptions.tsdoc && "object" == typeof options.apiModel && options.apiModel.tsdoc) lintOptions.tsdoc = options.apiModel.tsdoc;
+            plugins.push(TsDocLintPlugin(lintOptions));
+        }
         if ("dev" === target || "npm" === target) {
             if (!options.entry) plugins.push(AutoEntryPlugin({
                 exportsAsIndexes: options.exportsAsIndexes
@@ -1565,4 +1995,4 @@ const PackageJsonTransformPlugin = (options = {})=>{
         });
     }
 }
-export { AutoEntryPlugin, DtsPlugin, FilesArrayPlugin, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder };
+export { AutoEntryPlugin, DtsPlugin, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/rslib-builder",
-	"version": "0.3.0",
+	"version": "0.5.0",
 	"private": false,
 	"description": "RSlib-based build system for Node.js libraries with automatic package.json transformation, TypeScript declaration bundling, and multi-target support",
 	"homepage": "https://github.com/savvy-web/rslib-builder",
@@ -27,18 +27,22 @@
 		"@microsoft/tsdoc": "^0.16.0",
 		"@microsoft/tsdoc-config": "^0.18.0",
 		"@pnpm/exportable-manifest": "^1000.3.1",
+		"@typescript-eslint/parser": "^8.53.1",
+		"deep-equal": "^2.2.3",
+		"eslint": "^9.39.2",
+		"eslint-plugin-tsdoc": "^0.5.0",
 		"glob": "^13.0.0",
 		"picocolors": "^1.1.1",
-		"sort-package-json": "^3.6.0",
+		"sort-package-json": "^3.6.1",
 		"tmp": "^0.2.5",
-		"workspace-tools": "^0.40.3",
+		"workspace-tools": "^0.40.4",
 		"yaml": "^2.8.2"
 	},
 	"peerDependencies": {
 		"@microsoft/api-extractor": "^7.55.2",
-		"@rslib/core": "^0.19.2",
-		"@types/node": "^25.0.9",
-		"@typescript/native-preview": "^7.0.0-dev.20260120.1",
+		"@rslib/core": "^0.19.3",
+		"@types/node": "^25.0.10",
+		"@typescript/native-preview": "^7.0.0-dev.20260124.1",
 		"typescript": "^5.9.3"
 	},
 	"peerDependenciesMeta": {
@@ -48,11 +52,14 @@
 		"@rslib/core": {
 			"optional": false
 		},
+		"@types/node": {
+			"optional": false
+		},
 		"@typescript/native-preview": {
 			"optional": false
 		},
 		"typescript": {
-			"optional": false
+			"optional": true
 		}
 	},
 	"files": [

package/tsconfig/ecma/lib.json

@@ -11,7 +11,7 @@
 		"explainFiles": false,
 		"forceConsistentCasingInFileNames": true,
 		"incremental": true,
-		"isolatedDeclarations": true,
+		"isolatedDeclarations": false,
 		"isolatedModules": true,
 		"jsx": "preserve",
 		"lib": ["esnext"],