storybook-react-rsbuild 3.6.1 → 3.6.2

package/dist/chunks/{generate-1782ed11.js → generate-edd3f3a5.js}

@@ -1,6 +1,7 @@
 import "node:module";
 import magic_string from "magic-string";
 import typescript from "typescript";
+import { isSupportedRuntimeTargetExpression } from "./react-docgen-typescript-b22d46ea.js";
 function createLiteral(value) {
     switch(typeof value){
         case 'string':
@@ -22,8 +23,8 @@ function insertTsIgnoreBeforeStatement(statement) {
     ]);
     return statement;
 }
-function setDisplayName(d) {
-    return insertTsIgnoreBeforeStatement(typescript.factory.createExpressionStatement(typescript.factory.createBinaryExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier(d.displayName), typescript.factory.createIdentifier('displayName')), typescript.SyntaxKind.EqualsToken, typescript.factory.createStringLiteral(d.displayName))));
+function setDisplayName(d, target) {
+    return insertTsIgnoreBeforeStatement(typescript.factory.createExpressionStatement(typescript.factory.createBinaryExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier(target), typescript.factory.createIdentifier('displayName')), typescript.SyntaxKind.EqualsToken, typescript.factory.createStringLiteral(d.displayName))));
 }
 function createPropDefinition(propName, prop, options) {
     const setDefaultValue = (defaultValue)=>typescript.factory.createPropertyAssignment(typescript.factory.createStringLiteral('defaultValue'), defaultValue?.value !== void 0 && ('string' == typeof defaultValue.value || 'number' == typeof defaultValue.value || 'boolean' == typeof defaultValue.value) ? typescript.factory.createObjectLiteralExpression([
@@ -52,8 +53,8 @@ function createPropDefinition(propName, prop, options) {
         setType(prop.type.name, prop.type.value)
     ]));
 }
-function setComponentDocGen(d, options) {
-    return insertTsIgnoreBeforeStatement(typescript.factory.createExpressionStatement(typescript.factory.createBinaryExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier(d.displayName), typescript.factory.createIdentifier('__docgenInfo')), typescript.SyntaxKind.EqualsToken, typescript.factory.createObjectLiteralExpression([
+function setComponentDocGen(d, options, target) {
+    return insertTsIgnoreBeforeStatement(typescript.factory.createExpressionStatement(typescript.factory.createBinaryExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier(target), typescript.factory.createIdentifier('__docgenInfo')), typescript.SyntaxKind.EqualsToken, typescript.factory.createObjectLiteralExpression([
         typescript.factory.createPropertyAssignment(typescript.factory.createStringLiteral("description"), typescript.factory.createStringLiteral(d.description)),
         typescript.factory.createPropertyAssignment(typescript.factory.createStringLiteral('displayName'), typescript.factory.createStringLiteral(d.displayName)),
         typescript.factory.createPropertyAssignment(typescript.factory.createStringLiteral('props'), typescript.factory.createObjectLiteralExpression(Object.entries(d.props).map(([propName, prop])=>createPropDefinition(propName, prop, options))))
@@ -62,10 +63,16 @@ function setComponentDocGen(d, options) {
 function generateDocgenCodeBlock(options) {
     const sourceFile = typescript.createSourceFile(options.filename, options.source, typescript.ScriptTarget.ESNext);
     const wrapInTryStatement = (statements)=>typescript.factory.createTryStatement(typescript.factory.createBlock(statements, true), typescript.factory.createCatchClause(typescript.factory.createVariableDeclaration(typescript.factory.createIdentifier("__react_docgen_typescript_loader_error")), typescript.factory.createBlock([])), void 0);
-    const codeBlocks = options.componentDocs.map((d)=>wrapInTryStatement([
-            options.setDisplayName ? setDisplayName(d) : null,
-            setComponentDocGen(d, options)
-        ].filter((s)=>null !== s)));
+    const codeBlocks = options.componentDocs.flatMap((d)=>{
+        const target = d.targetExpression;
+        if (!target || !isSupportedRuntimeTargetExpression(target)) return [];
+        return [
+            wrapInTryStatement([
+                options.setDisplayName ? setDisplayName(d, target) : null,
+                setComponentDocGen(d, options, target)
+            ].filter((s)=>null !== s))
+        ];
+    });
     const printer = typescript.createPrinter({
         newLine: typescript.NewLineKind.LineFeed
     });
@@ -73,7 +80,10 @@ function generateDocgenCodeBlock(options) {
     const s = new magic_string(options.source, {
         filename: options.filename
     });
-    for (const node of codeBlocks)s.append(printNode(node));
+    if (codeBlocks.length > 0) {
+        const separator = options.source.endsWith('\n') ? '' : '\n';
+        s.append(separator + codeBlocks.map(printNode).join('\n'));
+    }
     return {
         code: s.toString(),
         map: s.generateMap({

package/dist/chunks/react-docgen-typescript-b22d46ea.js

@@ -0,0 +1,327 @@
+import "node:module";
+import { createFilter } from "@rollup/pluginutils";
+import { getDefaultExportForFile } from "react-docgen-typescript";
+const defaultPropFilter = (prop)=>!prop.parent?.fileName.includes('node_modules');
+const IDENTIFIER_PATH_PATTERN = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*(?:\.[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*)*$/u;
+const RESERVED_RUNTIME_TARGET_ROOTS = new Set([
+    'arguments',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+const isSupportedRuntimeTargetExpression = (value)=>{
+    if (!IDENTIFIER_PATH_PATTERN.test(value)) return false;
+    const [root] = value.split('.', 1);
+    return Boolean(root && !RESERVED_RUNTIME_TARGET_ROOTS.has(root));
+};
+const getNodeModifiers = (node)=>'modifiers' in node ? node.modifiers : void 0;
+const hasModifier = (node, modifierKind)=>Boolean(getNodeModifiers(node)?.some((modifier)=>modifier.kind === modifierKind));
+const getExpressionTargetText = (expression, sourceFile, tsModule)=>{
+    if (tsModule.isIdentifier(expression)) return expression.text;
+    if (tsModule.isPropertyAccessExpression(expression)) {
+        const targetExpression = expression.getText(sourceFile);
+        return isSupportedRuntimeTargetExpression(targetExpression) ? targetExpression : null;
+    }
+    return null;
+};
+const getDeclarationName = (declaration, tsModule)=>{
+    const named = tsModule.isArrowFunction(declaration) || tsModule.isFunctionExpression(declaration) || tsModule.isClassExpression(declaration) ? declaration.parent : declaration;
+    if ((tsModule.isVariableDeclaration(named) || tsModule.isBindingElement(named) || tsModule.isFunctionDeclaration(named) || tsModule.isClassDeclaration(named)) && named.name && tsModule.isIdentifier(named.name)) return named.name.text;
+    return null;
+};
+const getModuleScopePath = (declaration, tsModule)=>{
+    const namespacePath = [];
+    let node = declaration;
+    while(node.parent){
+        const parent = node.parent;
+        if (tsModule.isSourceFile(parent)) return namespacePath.reverse();
+        if (tsModule.isModuleBlock(parent)) {
+            const moduleDeclaration = parent.parent;
+            if (!hasModifier(node, tsModule.SyntaxKind.ExportKeyword) || !tsModule.isIdentifier(moduleDeclaration.name)) return null;
+            namespacePath.push(moduleDeclaration.name.text);
+            node = moduleDeclaration;
+            continue;
+        }
+        if (tsModule.isVariableDeclaration(parent) || tsModule.isVariableDeclarationList(parent) || tsModule.isVariableStatement(parent) || tsModule.isObjectBindingPattern(parent) || tsModule.isArrayBindingPattern(parent) || tsModule.isBindingElement(parent)) {
+            node = parent;
+            continue;
+        }
+        break;
+    }
+    return null;
+};
+const getDeclarationTarget = (declaration, sourceFile, tsModule)=>{
+    const name = getDeclarationName(declaration, tsModule);
+    if (name) {
+        const namespacePath = getModuleScopePath(declaration, tsModule);
+        return namespacePath ? [
+            ...namespacePath,
+            name
+        ].join('.') : null;
+    }
+    if (tsModule.isExportAssignment(declaration)) return getExpressionTargetText(declaration.expression, sourceFile, tsModule);
+    if (tsModule.isExportSpecifier(declaration)) {
+        const exportDeclaration = declaration.parent.parent;
+        if (tsModule.isExportDeclaration(exportDeclaration) && exportDeclaration.getSourceFile() === sourceFile && !exportDeclaration.moduleSpecifier) return declaration.propertyName?.text ?? declaration.name.text;
+    }
+    return null;
+};
+const getTargetFromSymbol = (symbol, checker, sourceFile, tsModule)=>{
+    const candidateSymbols = [
+        symbol
+    ];
+    if (symbol.flags & tsModule.SymbolFlags.Alias) try {
+        candidateSymbols.unshift(checker.getAliasedSymbol(symbol));
+    } catch  {}
+    for (const candidateSymbol of candidateSymbols){
+        const declarations = candidateSymbol.declarations ?? (candidateSymbol.valueDeclaration ? [
+            candidateSymbol.valueDeclaration
+        ] : []);
+        for (const declaration of declarations){
+            if (declaration.getSourceFile() !== sourceFile) continue;
+            if (tsModule.isShorthandPropertyAssignment(declaration)) {
+                const name = declaration.name.text;
+                const resolveAlias = (value)=>value && value.flags & tsModule.SymbolFlags.Alias ? checker.getAliasedSymbol(value) : value;
+                const valueSymbol = resolveAlias(checker.getShorthandAssignmentValueSymbol(declaration));
+                const moduleSymbol = resolveAlias(checker.resolveName(name, sourceFile, tsModule.SymbolFlags.Value | tsModule.SymbolFlags.Alias, false));
+                if (valueSymbol && moduleSymbol === valueSymbol && isSupportedRuntimeTargetExpression(name)) return name;
+                continue;
+            }
+            const targetExpression = getDeclarationTarget(declaration, sourceFile, tsModule);
+            if (targetExpression && isSupportedRuntimeTargetExpression(targetExpression)) return targetExpression;
+        }
+    }
+    return null;
+};
+const collectBindingTargets = (name, tsModule, targets)=>{
+    if (tsModule.isIdentifier(name)) return void targets.push(name.text);
+    for (const element of name.elements)if (tsModule.isBindingElement(element)) collectBindingTargets(element.name, tsModule, targets);
+};
+const getDeclarationStatementTarget = (statement, tsModule)=>{
+    if (tsModule.isVariableStatement(statement)) {
+        const targets = [];
+        for (const declaration of statement.declarationList.declarations)collectBindingTargets(declaration.name, tsModule, targets);
+        return targets;
+    }
+    if ((tsModule.isFunctionDeclaration(statement) || tsModule.isClassDeclaration(statement)) && statement.name) return [
+        statement.name.text
+    ];
+    return [];
+};
+const getNamedExportTargets = (sourceFile, tsModule)=>{
+    const namedExportTargets = new Set();
+    for (const statement of sourceFile.statements){
+        if (hasModifier(statement, tsModule.SyntaxKind.ExportKeyword) && !hasModifier(statement, tsModule.SyntaxKind.DefaultKeyword)) getDeclarationStatementTarget(statement, tsModule).forEach((target)=>{
+            namedExportTargets.add(target);
+        });
+        if (tsModule.isExportDeclaration(statement) && statement.exportClause && tsModule.isNamedExports(statement.exportClause) && !statement.moduleSpecifier) statement.exportClause.elements.forEach((element)=>{
+            if ('default' === element.name.text) return;
+            namedExportTargets.add(element.propertyName?.text ?? element.name.text);
+        });
+    }
+    return namedExportTargets;
+};
+const getDefaultExportTarget = (sourceFile, tsModule)=>{
+    for (const statement of sourceFile.statements){
+        if (tsModule.isExportAssignment(statement)) return getExpressionTargetText(statement.expression, sourceFile, tsModule);
+        if ((tsModule.isFunctionDeclaration(statement) || tsModule.isClassDeclaration(statement)) && hasModifier(statement, tsModule.SyntaxKind.ExportKeyword) && hasModifier(statement, tsModule.SyntaxKind.DefaultKeyword) && statement.name) return statement.name.text;
+        if (tsModule.isExportDeclaration(statement) && statement.exportClause && tsModule.isNamedExports(statement.exportClause) && !statement.moduleSpecifier) {
+            const defaultSpecifier = statement.exportClause.elements.find((element)=>'default' === element.name.text);
+            if (defaultSpecifier) return defaultSpecifier.propertyName?.text ?? defaultSpecifier.name.text;
+        }
+    }
+    return null;
+};
+const resolveTargetExpression = (componentDoc, checker, sourceFile, namedExportTargets, tsModule)=>{
+    if (componentDoc.expression) {
+        const targetFromExpression = getTargetFromSymbol(componentDoc.expression, checker, sourceFile, tsModule);
+        if (targetFromExpression) return targetFromExpression;
+    }
+    if (namedExportTargets.has(componentDoc.displayName)) return componentDoc.displayName;
+    if (componentDoc.displayName.includes('.') && isSupportedRuntimeTargetExpression(componentDoc.displayName)) return componentDoc.displayName;
+    return null;
+};
+function resolveComponentDocRuntimeTargets(componentDocs, checker, sourceFile, tsModule) {
+    const namedExportTargets = getNamedExportTargets(sourceFile, tsModule);
+    const defaultExportTarget = getDefaultExportTarget(sourceFile, tsModule);
+    const defaultExportDisplayName = getDefaultExportForFile(sourceFile);
+    const usedTargets = new Set();
+    const resolvedComponentDocs = componentDocs.map((componentDoc)=>{
+        const targetExpression = resolveTargetExpression(componentDoc, checker, sourceFile, namedExportTargets, tsModule);
+        if (targetExpression) usedTargets.add(targetExpression);
+        return {
+            ...componentDoc,
+            targetExpression
+        };
+    });
+    if (!defaultExportTarget || usedTargets.has(defaultExportTarget)) return resolvedComponentDocs;
+    const unresolvedDocs = resolvedComponentDocs.filter((componentDoc)=>!componentDoc.targetExpression);
+    const defaultExportDoc = unresolvedDocs.find((componentDoc)=>componentDoc.displayName === defaultExportDisplayName) ?? (1 === unresolvedDocs.length ? unresolvedDocs[0] : void 0);
+    if (defaultExportDoc) defaultExportDoc.targetExpression = defaultExportTarget;
+    return resolvedComponentDocs;
+}
+const getDocgen = async (config)=>{
+    const docGen = await import("react-docgen-typescript");
+    const { tsconfigPath, compilerOptions, propFilter = defaultPropFilter, setDisplayName, typePropName, ...rest } = config;
+    const docgenOptions = {
+        propFilter,
+        ...rest,
+        shouldIncludeExpression: true
+    };
+    return docGen.withCompilerOptions({}, docgenOptions);
+};
+const startProgram = async (config, isBuild, onProgramCreatedOrUpdated)=>{
+    const { default: ts } = await import("typescript");
+    const { getTSConfigFile } = await import("./typescript-69cd7fa9.js");
+    let compilerOptions = {
+        jsx: ts.JsxEmit.React,
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.Latest
+    };
+    const tsconfigPath = config.tsconfigPath ?? './tsconfig.json';
+    if (config.compilerOptions) compilerOptions = {
+        ...compilerOptions,
+        ...config.compilerOptions
+    };
+    else {
+        const { options: tsOptions } = getTSConfigFile(tsconfigPath);
+        compilerOptions = {
+            ...compilerOptions,
+            ...tsOptions
+        };
+    }
+    if (isBuild) {
+        const tsConfig = getTSConfigFile(tsconfigPath);
+        const program = ts.createProgram({
+            rootNames: tsConfig.fileNames ?? [],
+            options: {
+                ...tsConfig.options,
+                ...compilerOptions
+            },
+            projectReferences: tsConfig.projectReferences
+        });
+        return [
+            program,
+            ()=>{},
+            ts
+        ];
+    }
+    const host = ts.createWatchCompilerHost(tsconfigPath, compilerOptions, ts.sys, ts.createSemanticDiagnosticsBuilderProgram, void 0, ()=>{});
+    host.afterProgramCreate = (program)=>{
+        onProgramCreatedOrUpdated(program.getProgram());
+    };
+    return new Promise((resolve)=>{
+        const watch = ts.createWatchProgram(host);
+        resolve([
+            watch.getProgram().getProgram(),
+            ()=>watch.close(),
+            ts
+        ]);
+    });
+};
+const react_docgen_typescript = (config = {})=>{
+    let tsProgram;
+    let tsModule;
+    let docGenParser;
+    let generateDocgenCodeBlock;
+    let generateOptions;
+    let filter;
+    const moduleInvalidationQueue = new Map();
+    let closeWatch;
+    return {
+        name: "rsbuild-plugin-react-docgen-typescript",
+        setup (api) {
+            api.modifyRsbuildConfig(async ()=>{
+                const { getGenerateOptions } = await import("./options-7e849a08.js");
+                generateDocgenCodeBlock = (await import("./generate-edd3f3a5.js")).generateDocgenCodeBlock;
+                docGenParser = await getDocgen(config);
+                generateOptions = getGenerateOptions(config);
+                [tsProgram, closeWatch, tsModule] = await startProgram(config, 'build' === api.context.action, (program)=>{
+                    tsProgram = program;
+                    for (const [filepath, invalidateModule] of moduleInvalidationQueue.entries()){
+                        invalidateModule();
+                        moduleInvalidationQueue.delete(filepath);
+                    }
+                });
+                filter = createFilter(config.include ?? [
+                    '**/**.tsx'
+                ], config.exclude ?? [
+                    '**/**.stories.tsx'
+                ]);
+            });
+            api.transform({
+                test: (id)=>filter(id)
+            }, async ({ code: src, resource: id })=>{
+                try {
+                    const componentDocs = docGenParser.parseWithProgramProvider(id, ()=>tsProgram);
+                    if (!componentDocs.length) return {
+                        code: src
+                    };
+                    const sourceFile = tsProgram.getSourceFile(id);
+                    if (!sourceFile) return {
+                        code: src
+                    };
+                    const resolvedDocs = resolveComponentDocRuntimeTargets(componentDocs, tsProgram.getTypeChecker(), sourceFile, tsModule);
+                    const res = generateDocgenCodeBlock({
+                        filename: id,
+                        source: src,
+                        componentDocs: resolvedDocs,
+                        ...generateOptions
+                    });
+                    return res;
+                } catch (_e) {
+                    return src;
+                }
+            });
+            const close = ()=>closeWatch?.();
+            api.onCloseBuild(close);
+            api.onCloseDevServer(close);
+        }
+    };
+};
+export default react_docgen_typescript;
+export { isSupportedRuntimeTargetExpression };

package/dist/loaders/react-docgen-loader.js

@@ -66,7 +66,7 @@ function defaultLookupModule(filename, basedir) {
         });
     }
 }
-const { getNameOrValue: getNameOrValue, isReactForwardRefCall: isReactForwardRefCall } = utils;
+const { getNameOrValue, isReactForwardRefCall } = utils;
 const react_docgen_loader_actualNameHandler = function(documentation, componentDefinition) {
     documentation.set('definedInFile', componentDefinition.hub.file.opts.filename);
     if ((componentDefinition.isClassDeclaration() || componentDefinition.isFunctionDeclaration()) && componentDefinition.has('id')) documentation.set('actualName', getNameOrValue(componentDefinition.get('id')));
@@ -98,7 +98,7 @@ async function reactDocgenLoader(source, map) {
         const docgenResults = parse(source, {
             filename: this.resourcePath,
             resolver: defaultResolver,
-            handlers: handlers,
+            handlers,
             importer: getReactDocgenImporter(matchPath),
             babelOptions: {
                 babelrc: false,

package/dist/preset.js

@@ -41,7 +41,7 @@ const rsbuildFinalDocs = async (config, options)=>{
             }
         }
     });
-    const reactDocGenTsPlugin = await import("./chunks/react-docgen-typescript-16ec96c4.js");
+    const reactDocGenTsPlugin = await import("./chunks/react-docgen-typescript-b22d46ea.js");
     return mergeRsbuildConfig(config, {
         tools: {
             rspack: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storybook-react-rsbuild",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "description": "Storybook for React and Rsbuild: Develop React components in isolation with Hot Reloading.",
   "keywords": [
     "storybook",
@@ -46,32 +46,32 @@
     "!src/**/*"
   ],
   "dependencies": {
-    "@rollup/pluginutils": "^5.4.0",
-    "@storybook/react": "^10.6.0",
+    "@rollup/pluginutils": "^5.5.1",
+    "@storybook/react": "^10.6.5",
     "@storybook/react-docgen-typescript-plugin": "^1.0.1",
-    "magic-string": "^1.4.2",
+    "magic-string": "^1.4.5",
     "react-docgen": "^8.0.4",
     "react-docgen-typescript": "^2.4.0",
-    "resolve": "^1.22.12",
+    "resolve": "^1.22.14",
     "tsconfig-paths": "^4.2.0",
-    "storybook-builder-rsbuild": "3.6.1"
+    "storybook-builder-rsbuild": "3.6.2"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.59.3",
-    "@rsbuild/core": "^2.2.11",
+    "@microsoft/api-extractor": "^7.60.1",
+    "@rsbuild/core": "^2.2.14",
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.31",
     "@types/resolve": "^1.20.6",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "storybook": "10.6.0",
+    "storybook": "10.6.5",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "@rsbuild/core": "^1.5.0 || ^2.0.0-0",
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
     "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-    "storybook": "^10.6.0",
+    "storybook": "^10.6.5",
     "typescript": ">= 4.2.x"
   },
   "peerDependenciesMeta": {
@@ -95,7 +95,7 @@
     "platform": "node"
   },
   "scripts": {
-    "build": "rstack lib",
-    "dev": "rstack lib --watch"
+    "build": "rs lib",
+    "dev": "rs lib --watch"
   }
 }

package/dist/chunks/react-docgen-typescript-16ec96c4.js

@@ -1,114 +0,0 @@
-import "node:module";
-import { createFilter } from "@rollup/pluginutils";
-const defaultPropFilter = (prop)=>!prop.parent?.fileName.includes('node_modules');
-const getDocgen = async (config)=>{
-    const docGen = await import("react-docgen-typescript");
-    const { tsconfigPath, compilerOptions, propFilter = defaultPropFilter, setDisplayName, typePropName, ...rest } = config;
-    const docgenOptions = {
-        propFilter,
-        ...rest
-    };
-    return docGen.withCompilerOptions({}, docgenOptions);
-};
-const startProgram = async (config, isBuild, onProgramCreatedOrUpdated)=>{
-    const { default: ts } = await import("typescript");
-    const { getTSConfigFile } = await import("./typescript-69cd7fa9.js");
-    let compilerOptions = {
-        jsx: ts.JsxEmit.React,
-        module: ts.ModuleKind.CommonJS,
-        target: ts.ScriptTarget.Latest
-    };
-    const tsconfigPath = config.tsconfigPath ?? './tsconfig.json';
-    if (config.compilerOptions) compilerOptions = {
-        ...compilerOptions,
-        ...config.compilerOptions
-    };
-    else {
-        const { options: tsOptions } = getTSConfigFile(tsconfigPath);
-        compilerOptions = {
-            ...compilerOptions,
-            ...tsOptions
-        };
-    }
-    if (isBuild) {
-        const tsConfig = getTSConfigFile(tsconfigPath);
-        const program = ts.createProgram({
-            rootNames: tsConfig.fileNames ?? [],
-            options: {
-                ...tsConfig.options,
-                ...compilerOptions
-            },
-            projectReferences: tsConfig.projectReferences
-        });
-        return [
-            program,
-            ()=>{}
-        ];
-    }
-    const host = ts.createWatchCompilerHost(tsconfigPath, compilerOptions, ts.sys, ts.createSemanticDiagnosticsBuilderProgram, void 0, ()=>{});
-    host.afterProgramCreate = (program)=>{
-        onProgramCreatedOrUpdated(program.getProgram());
-    };
-    return new Promise((resolve)=>{
-        const watch = ts.createWatchProgram(host);
-        resolve([
-            watch.getProgram().getProgram(),
-            ()=>watch.close()
-        ]);
-    });
-};
-const react_docgen_typescript = (config = {})=>{
-    let tsProgram;
-    let docGenParser;
-    let generateDocgenCodeBlock;
-    let generateOptions;
-    let filter;
-    const moduleInvalidationQueue = new Map();
-    let closeWatch;
-    return {
-        name: "rsbuild-plugin-react-docgen-typescript",
-        setup (api) {
-            api.modifyRsbuildConfig(async ()=>{
-                const { getGenerateOptions } = await import("./options-7e849a08.js");
-                generateDocgenCodeBlock = (await import("./generate-1782ed11.js")).generateDocgenCodeBlock;
-                docGenParser = await getDocgen(config);
-                generateOptions = getGenerateOptions(config);
-                [tsProgram, closeWatch] = await startProgram(config, 'build' === api.context.action, (program)=>{
-                    tsProgram = program;
-                    for (const [filepath, invalidateModule] of moduleInvalidationQueue.entries()){
-                        invalidateModule();
-                        moduleInvalidationQueue.delete(filepath);
-                    }
-                });
-                filter = createFilter(config.include ?? [
-                    '**/**.tsx'
-                ], config.exclude ?? [
-                    '**/**.stories.tsx'
-                ]);
-            });
-            api.transform({
-                test: (id)=>filter(id)
-            }, async ({ code: src, resource: id })=>{
-                try {
-                    const componentDocs = docGenParser.parseWithProgramProvider(id, ()=>tsProgram);
-                    if (!componentDocs.length) return {
-                        code: src
-                    };
-                    const res = generateDocgenCodeBlock({
-                        filename: id,
-                        source: src,
-                        componentDocs,
-                        ...generateOptions
-                    });
-                    return res;
-                } catch (_e) {
-                    return src;
-                }
-            });
-            const close = ()=>closeWatch?.();
-            api.onCloseBuild(close);
-            api.onCloseDevServer(close);
-        }
-    };
-};
-export default react_docgen_typescript;