@modern-js/storybook-builder 0.0.0-next-20230913035856

package/dist/esm/core.js

@@ -0,0 +1,30 @@
+import { createBuilder, mergeBuilderConfig } from "@modern-js/builder";
+import { loadConfig } from "@modern-js/core";
+import { getProvider, runWithErrorMsg } from "./utils";
+import { pluginStorybook } from "./plugin-storybook";
+export async function getCompiler(cwd, frameworkConfig, options) {
+  const bundler = frameworkConfig.bundler || "webpack";
+  const { presets } = options;
+  const entries = await presets.apply("entries", []);
+  const res = await runWithErrorMsg(() => loadConfig(cwd, frameworkConfig.configPath || "modern.config.ts"), "Failed to load config");
+  const loadedConfig = res ? res.config : {};
+  const otherBuilderConfig = await presets.apply("modern", loadedConfig) || {};
+  const builderConfig = mergeBuilderConfig(otherBuilderConfig, loadedConfig);
+  const provider = await getProvider(bundler, builderConfig);
+  if (!provider) {
+    throw new Error(`@modern-js/builder-${bundler}-provider not found `);
+  }
+  const builder = await createBuilder(provider, {
+    cwd,
+    target: "web",
+    framework: "modern.js storybook",
+    entry: {
+      main: entries
+    }
+  });
+  builder.addPlugins([
+    pluginStorybook(cwd, options),
+    ...loadedConfig.builderPlugins || []
+  ]);
+  return builder.createCompiler();
+}

package/dist/esm/docgen/actualNameHandler.js

@@ -0,0 +1,24 @@
+import { namedTypes as t } from "ast-types";
+import { getNameOrValue, isReactForwardRefCall } from "react-docgen/dist/utils";
+export default function actualNameHandler(documentation, path, importer) {
+  if (t.ClassDeclaration.check(path.node) || t.FunctionDeclaration.check(path.node)) {
+    documentation.set("actualName", getNameOrValue(path.get("id")));
+  } else if (t.ArrowFunctionExpression.check(path.node) || t.FunctionExpression.check(path.node) || isReactForwardRefCall(path, importer)) {
+    let currentPath = path;
+    while (currentPath.parent) {
+      if (t.VariableDeclarator.check(currentPath.parent.node)) {
+        documentation.set("actualName", getNameOrValue(currentPath.parent.get("id")));
+        return;
+      }
+      if (t.AssignmentExpression.check(currentPath.parent.node)) {
+        const leftPath = currentPath.parent.get("left");
+        if (t.Identifier.check(leftPath.node) || t.Literal.check(leftPath.node)) {
+          documentation.set("actualName", getNameOrValue(leftPath));
+          return;
+        }
+      }
+      currentPath = currentPath.parent;
+    }
+    documentation.set("actualName", "");
+  }
+}

package/dist/esm/docgen/index.js

@@ -0,0 +1,54 @@
+import { CHAIN_ID, logger } from "@modern-js/utils";
+export async function applyDocgenWebpack(chain, options) {
+  const typescriptOptions = await options.presets.apply("typescript", {});
+  const { reactDocgen, reactDocgenTypescriptOptions } = typescriptOptions || {};
+  if (typeof reactDocgen !== "string") {
+    return;
+  }
+  if (reactDocgen === "react-docgen-typescript") {
+    const { ReactDocgenTypeScriptPlugin } = await import("@storybook/react-docgen-typescript-plugin");
+    chain.plugin("Storybook-docgen").use(ReactDocgenTypeScriptPlugin, [
+      {
+        ...reactDocgenTypescriptOptions,
+        savePropValueAsString: true
+      }
+    ]);
+  } else if (reactDocgen === "react-docgen") {
+    const loader = require.resolve("./loader");
+    const resolveOptions = chain.toConfig().resolve;
+    chain.module.rule(CHAIN_ID.RULE.JS).use(CHAIN_ID.USE.REACT_DOCGEN).loader(loader).options({
+      resolveOptions
+    }).after(CHAIN_ID.USE.BABEL).after(CHAIN_ID.USE.ESBUILD).after(CHAIN_ID.USE.SWC).end();
+    const tsRuls = chain.module.rule(CHAIN_ID.RULE.TS);
+    if (tsRuls.uses.values().length !== 0) {
+      tsRuls.use(CHAIN_ID.USE.REACT_DOCGEN).loader(loader).options({
+        resolveOptions
+      }).after(CHAIN_ID.USE.TS).after(CHAIN_ID.USE.ESBUILD).after(CHAIN_ID.USE.SWC).end();
+    }
+  }
+}
+export async function applyDocgenRspack(config, options) {
+  var _config, _config_module;
+  const typescriptOptions = await options.presets.apply("typescript", {});
+  const { reactDocgen } = typescriptOptions || {};
+  if (reactDocgen !== "react-docgen") {
+    if (reactDocgen !== false && reactDocgen !== void 0) {
+      logger.warn(`Rspack currently only support 'typescript.reactDocgen: react-docgen' for auto docs generation, but you specified ${reactDocgen}`);
+    }
+    return;
+  }
+  var _module;
+  (_module = (_config = config).module) !== null && _module !== void 0 ? _module : _config.module = {};
+  var _rules;
+  (_rules = (_config_module = config.module).rules) !== null && _rules !== void 0 ? _rules : _config_module.rules = [];
+  config.module.rules.push({
+    test: /\.(tsx?|jsx?)$/,
+    exclude: /node_modules/,
+    use: {
+      loader: require.resolve("./loader"),
+      options: {
+        resolveOptions: config.resolve
+      }
+    }
+  });
+}

package/dist/esm/docgen/loader.js

@@ -0,0 +1,26 @@
+let tinyPoolPromise = null;
+async function docLoader(source, map, data) {
+  const callback = this.async();
+  if (!tinyPoolPromise) {
+    tinyPoolPromise = import("tinypool").then(({ Tinypool }) => {
+      return new Tinypool({
+        filename: require.resolve("./process")
+      });
+    });
+  }
+  const tinyPool = await tinyPoolPromise;
+  const result = await tinyPool.run({
+    source,
+    map,
+    filename: this.resourcePath,
+    data
+  });
+  if (result) {
+    const [docgen, outputMap] = result;
+    callback(null, `${source}
+${docgen}`, outputMap, data);
+  } else {
+    callback(null, source, map, data);
+  }
+}
+export default docLoader;

package/dist/esm/docgen/process.js

@@ -0,0 +1,28 @@
+import { importers, resolver, handlers, parse } from "react-docgen";
+import actualNameHandler from "./actualNameHandler";
+const defaultHandlers = Object.values(handlers).map((handler) => handler);
+const importer = importers.makeFsImporter();
+export default ({ source, map, filename }) => {
+  try {
+    const results = parse(source, resolver.findAllExportedComponentDefinitions, [
+      ...defaultHandlers,
+      actualNameHandler
+    ], {
+      filename,
+      importer
+    });
+    const docgen = results.map((result) => {
+      const { actualName, ...docgenInfo } = result;
+      if (actualName) {
+        return `${actualName}.__docgenInfo=${JSON.stringify(docgenInfo)}`;
+      }
+      return "";
+    }).filter(Boolean).join(";");
+    return [
+      docgen,
+      map
+    ];
+  } catch (e) {
+    return null;
+  }
+};

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import { join } from "path";
+export { start, build, bail, getConfig } from "./build";
+export * from "./types";
+export const corePresets = [
+  join(__dirname, "./preset.js")
+];

package/dist/esm/plugin-storybook.js

@@ -0,0 +1,296 @@
+import { isAbsolute, join, resolve } from "path";
+import { slash, watch, globby } from "@modern-js/utils";
+import { mergeBuilderConfig } from "@modern-js/builder-shared";
+import { normalizeStories, stringifyProcessEnvs, handlebars, readTemplate, loadPreviewOrConfigFile } from "@storybook/core-common";
+import { globals } from "@storybook/preview/globals";
+import { unplugin as csfPlugin } from "@storybook/csf-plugin";
+import { minimatch } from "minimatch";
+import { toImportFn, virtualModule, maybeGetAbsolutePath } from "./utils";
+import { applyDocgenRspack, applyDocgenWebpack } from "./docgen";
+const STORIES_FILENAME = "storybook-stories.js";
+const STORYBOOK_CONFIG_ENTRY = "storybook-config-entry.js";
+const closeFn = [];
+const onClose = (f) => {
+  closeFn.push(f);
+};
+export async function finalize() {
+  await Promise.all([
+    closeFn.map((close) => close())
+  ]);
+}
+export const pluginStorybook = (cwd, options) => {
+  return {
+    name: "builder-plugin-storybook",
+    remove: [
+      "builder-plugin-inline"
+    ],
+    async setup(api) {
+      const matchers = await options.presets.apply("stories", [], options);
+      const storyPatterns = normalizeStories(matchers, {
+        configDir: options.configDir,
+        workingDir: options.configDir
+      }).map(({ directory, files }) => {
+        const pattern = join(directory, files);
+        const absolutePattern = isAbsolute(pattern) ? pattern : join(options.configDir, pattern);
+        return absolutePattern;
+      });
+      api.modifyBuilderConfig(async (builderConfig) => {
+        await prepareStorybookModules(api.context.cachePath, cwd, options, builderConfig, storyPatterns);
+        await applyDefines(builderConfig, options);
+        await applyHTML(builderConfig, options);
+        await applyReact(builderConfig, options);
+        applyExternals(builderConfig);
+      });
+      const modifyConfig = async (config) => {
+        var _config;
+        var _resolve;
+        (_resolve = (_config = config).resolve) !== null && _resolve !== void 0 ? _resolve : _config.resolve = {};
+        config.resolve.conditionNames = [
+          "require",
+          "node",
+          ...config.resolve.conditionNames || []
+        ];
+        config.resolve.fullySpecified = false;
+        await applyMdxLoader(config, options);
+        await applyCsfPlugin(config, options);
+      };
+      if ("modifyWebpackConfig" in api) {
+        api.modifyWebpackConfig(modifyConfig);
+        api.modifyWebpackChain(async (chain) => {
+          await applyDocgenWebpack(chain, options);
+        });
+      } else if ("modifyRspackConfig" in api) {
+        api.modifyRspackConfig(async (config) => {
+          await modifyConfig(config);
+          await applyDocgenRspack(config, options);
+        });
+      }
+    }
+  };
+};
+async function applyCsfPlugin(config, options) {
+  var _addons_find;
+  var _config;
+  const { presets } = options;
+  const addons = await presets.apply("addons", []);
+  const { options: { bundler } } = await presets.apply("frameworkOptions");
+  var _addons_find_options;
+  const docsOptions = (_addons_find_options = (_addons_find = addons.find((a) => [
+    a,
+    a.name
+  ].includes("@storybook/addon-docs"))) === null || _addons_find === void 0 ? void 0 : _addons_find.options) !== null && _addons_find_options !== void 0 ? _addons_find_options : {};
+  var _plugins;
+  (_plugins = (_config = config).plugins) !== null && _plugins !== void 0 ? _plugins : _config.plugins = [];
+  config.plugins.push(bundler === "rspack" ? csfPlugin.rspack(docsOptions) : csfPlugin.webpack(docsOptions));
+}
+async function prepareStorybookModules(tempDir, cwd, options, builderConfig, storyPatterns) {
+  var _builderConfig;
+  const mappings = await createStorybookModules(cwd, options, storyPatterns);
+  const componentsPath = maybeGetAbsolutePath(`@storybook/components`);
+  const routerPath = maybeGetAbsolutePath(`@storybook/router`);
+  const themingPath = maybeGetAbsolutePath(`@storybook/theming`);
+  const storybookPaths = {
+    ...componentsPath ? {
+      [`@storybook/components`]: componentsPath
+    } : {},
+    ...routerPath ? {
+      [`@storybook/router`]: routerPath
+    } : {},
+    ...themingPath ? {
+      [`@storybook/theming`]: themingPath
+    } : {}
+  };
+  const [mappingsAlias, write] = await virtualModule(tempDir, cwd, mappings);
+  var _source;
+  (_source = (_builderConfig = builderConfig).source) !== null && _source !== void 0 ? _source : _builderConfig.source = {};
+  builderConfig.source.alias = {
+    ...builderConfig.source.alias,
+    ...storybookPaths,
+    ...mappingsAlias
+  };
+  const watcher = await watchStories(storyPatterns, cwd, write);
+  onClose(async () => {
+    await watcher.close();
+  });
+}
+async function applyDefines(builderConfig, options) {
+  var _builderConfig;
+  const { presets } = options;
+  const envs = await presets.apply("env");
+  var _source;
+  (_source = (_builderConfig = builderConfig).source) !== null && _source !== void 0 ? _source : _builderConfig.source = {};
+  builderConfig.source.define = {
+    ...builderConfig.source.define,
+    ...stringifyProcessEnvs(envs),
+    "process.env": JSON.stringify(envs),
+    NODE_ENV: JSON.stringify(process.env.NODE_ENV)
+  };
+}
+async function applyHTML(builderConfig, options) {
+  var _builderConfig;
+  const { presets, packageJson, configType, features, previewUrl, serverChannelUrl } = options;
+  const [coreOptions, frameworkOptions, logLevel, headHtmlSnippet, bodyHtmlSnippet, template, docsOptions] = await Promise.all([
+    presets.apply("core"),
+    presets.apply("frameworkOptions"),
+    presets.apply("logLevel", void 0),
+    presets.apply("previewHead"),
+    presets.apply("previewBody"),
+    presets.apply("previewMainTemplate"),
+    presets.apply("docs")
+  ]);
+  var _tools;
+  (_tools = (_builderConfig = builderConfig).tools) !== null && _tools !== void 0 ? _tools : _builderConfig.tools = {};
+  builderConfig.tools.htmlPlugin = {
+    ...builderConfig.tools.htmlPlugin,
+    template,
+    filename: "iframe.html",
+    templateParameters: {
+      ...builderConfig.tools.htmlPlugin ? builderConfig.tools.htmlPlugin.templateParameters || {} : {},
+      version: packageJson.version || "",
+      globals: {
+        CONFIG_TYPE: configType,
+        LOGLEVEL: logLevel,
+        FRAMEWORK_OPTIONS: frameworkOptions,
+        CHANNEL_OPTIONS: coreOptions.channelOptions,
+        FEATURES: features,
+        PREVIEW_URL: previewUrl,
+        DOCS_OPTIONS: docsOptions,
+        SERVER_CHANNEL_URL: serverChannelUrl
+      },
+      headHtmlSnippet,
+      bodyHtmlSnippet
+    },
+    inject: false
+  };
+}
+async function applyMdxLoader(config, options) {
+  var _mdxPluginOptions, _mdxPluginOptions_mdxCompileOptions, _mdxPluginOptions1, _options_features;
+  var _config, _config_module;
+  const { presets, mdxPluginOptions } = options;
+  const remarkExternalLinks = await import("remark-external-links");
+  const remarkSlug = await import("remark-slug");
+  var _mdxPluginOptions_mdxCompileOptions_remarkPlugins;
+  const mdxLoaderOptions = await presets.apply("mdxLoaderOptions", {
+    skipCsf: true,
+    mdxCompileOptions: {
+      providerImportSource: "@storybook/addon-docs/mdx-react-shim",
+      ...(_mdxPluginOptions = mdxPluginOptions) === null || _mdxPluginOptions === void 0 ? void 0 : _mdxPluginOptions.mdxCompileOptions,
+      remarkPlugins: [
+        remarkSlug,
+        remarkExternalLinks,
+        ...(_mdxPluginOptions_mdxCompileOptions_remarkPlugins = (_mdxPluginOptions1 = mdxPluginOptions) === null || _mdxPluginOptions1 === void 0 ? void 0 : (_mdxPluginOptions_mdxCompileOptions = _mdxPluginOptions1.mdxCompileOptions) === null || _mdxPluginOptions_mdxCompileOptions === void 0 ? void 0 : _mdxPluginOptions_mdxCompileOptions.remarkPlugins) !== null && _mdxPluginOptions_mdxCompileOptions_remarkPlugins !== void 0 ? _mdxPluginOptions_mdxCompileOptions_remarkPlugins : []
+      ]
+    }
+  });
+  const mdxLoader = ((_options_features = options.features) === null || _options_features === void 0 ? void 0 : _options_features.legacyMdx1) ? require.resolve("@storybook/mdx1-csf/loader") : require.resolve("@storybook/mdx2-csf/loader");
+  var _module;
+  (_module = (_config = config).module) !== null && _module !== void 0 ? _module : _config.module = {};
+  var _rules;
+  (_rules = (_config_module = config.module).rules) !== null && _rules !== void 0 ? _rules : _config_module.rules = [];
+  config.module.rules.push({
+    test: /(stories|story)\.mdx$/,
+    use: [
+      {
+        loader: mdxLoader,
+        options: {
+          ...mdxLoaderOptions,
+          skipCsf: false
+        }
+      }
+    ]
+  }, {
+    test: /\.mdx$/,
+    exclude: /(stories|story)\.mdx$/,
+    use: [
+      {
+        loader: mdxLoader,
+        options: mdxLoaderOptions
+      }
+    ]
+  });
+}
+function applyExternals(builderConfig) {
+  var _builderConfig_output;
+  const config = mergeBuilderConfig({
+    output: {
+      externals: (_builderConfig_output = builderConfig.output) === null || _builderConfig_output === void 0 ? void 0 : _builderConfig_output.externals
+    }
+  }, {
+    output: {
+      externals: globals
+    }
+  });
+  builderConfig.output = config.output;
+}
+function getStoriesEntryPath(cwd) {
+  return resolve(join(cwd, STORIES_FILENAME));
+}
+function getStoriesConfigPath(cwd) {
+  return resolve(join(cwd, STORYBOOK_CONFIG_ENTRY));
+}
+async function createStorybookModules(cwd, options, storyPatterns) {
+  const virtualModuleMappings = {};
+  const { presets } = options;
+  const storiesEntry = await createStoriesEntry(cwd, storyPatterns);
+  virtualModuleMappings[getStoriesEntryPath(cwd)] = storiesEntry;
+  const configEntryPath = getStoriesConfigPath(cwd);
+  const previewAnnotations = [
+    ...(await presets.apply("previewAnnotations", [], options)).map((entry) => {
+      if (typeof entry === "object") {
+        return entry.absolute;
+      }
+      return resolve(cwd, slash(entry));
+    }),
+    loadPreviewOrConfigFile(options)
+  ].filter(Boolean);
+  virtualModuleMappings[configEntryPath] = handlebars(await readTemplate(require.resolve("@modern-js/storybook-builder/templates/virtualModuleModernEntry.js.handlebars")), {
+    storiesFilename: STORIES_FILENAME,
+    previewAnnotations
+  }).replace(/\\/g, "\\\\");
+  return virtualModuleMappings;
+}
+async function createStoriesEntry(cwd, storyPatterns) {
+  const stories = (await Promise.all(storyPatterns.map((pattern) => {
+    return globby(slash(pattern), {
+      followSymbolicLinks: true
+    });
+  }))).reduce((carry, stories2) => carry.concat(stories2), []);
+  return await toImportFn(cwd, stories);
+}
+async function applyReact(config, options) {
+  let version = "18.0.0";
+  try {
+    ({ version } = await import("react-dom/package.json"));
+  } catch (_) {
+  }
+  const { legacyRootApi } = await options.presets.apply("frameworkOptions") || {};
+  const isReact18 = version.startsWith("18") || version.startsWith("0.0.0");
+  const useReact17 = legacyRootApi !== null && legacyRootApi !== void 0 ? legacyRootApi : !isReact18;
+  if (!useReact17) {
+    var _config, _config_source;
+    var _source;
+    (_source = (_config = config).source) !== null && _source !== void 0 ? _source : _config.source = {};
+    var _alias;
+    (_alias = (_config_source = config.source).alias) !== null && _alias !== void 0 ? _alias : _config_source.alias = {};
+    config.source.alias["@storybook/react-dom-shim"] = "@storybook/react-dom-shim/dist/react-18";
+  }
+}
+async function watchStories(patterns, cwd, writeModule) {
+  const watcher = watch(cwd, async ({ changeType, changedFilePath }) => {
+    if (changeType !== "add" && changeType !== "unlink") {
+      return;
+    }
+    if (patterns.some((entry) => minimatch(changedFilePath, entry))) {
+      const stories = (await Promise.all(patterns.map((pattern) => {
+        return globby(slash(pattern), {
+          followSymbolicLinks: true
+        });
+      }))).reduce((carry, stories2) => carry.concat(stories2), []);
+      const newStories = await toImportFn(cwd, stories);
+      writeModule(getStoriesEntryPath(cwd), newStories);
+    }
+  }, [
+    /node_modules/
+  ]);
+  return watcher;
+}

package/dist/esm/preset.js

@@ -0,0 +1,36 @@
+import { join, resolve } from "path";
+import { getConfig } from "./build";
+import { STORYBOOK_CONFIG_ENTRY } from "./utils";
+export const previewMainTemplate = () => {
+  return require.resolve("@modern-js/storybook-builder/templates/preview.ejs");
+};
+function getStoriesConfigPath(cwd) {
+  return resolve(join(cwd, STORYBOOK_CONFIG_ENTRY));
+}
+export const entries = async (_, options) => {
+  const result = [];
+  const { bundler } = await getConfig(options);
+  if (options.configType === "DEVELOPMENT") {
+    result.push(...[
+      `${require.resolve("webpack-hot-middleware/client")}?reload=true&quiet=false&noInfo=${options.quiet}`,
+      bundler === "rspack" ? require.resolve("@rspack/dev-client/react-refresh-entry") : null
+    ].filter(Boolean));
+  }
+  result.push(getStoriesConfigPath(process.cwd()));
+  return result;
+};
+export const modern = (builderConfig, options) => {
+  var _builderConfig_output;
+  return {
+    ...builderConfig,
+    output: {
+      ...builderConfig.output,
+      disableInlineRuntimeChunk: true,
+      distPath: {
+        ...(_builderConfig_output = builderConfig.output) === null || _builderConfig_output === void 0 ? void 0 : _builderConfig_output.distPath,
+        root: options.outputDir
+      }
+    }
+  };
+};
+export { decorators } from "./addons/preset/preview";

package/dist/esm/types.js

@@ -0,0 +1 @@
+export { defineConfig } from "@modern-js/builder/cli";

package/dist/esm/utils.js

@@ -0,0 +1,95 @@
+import path, { dirname, join } from "path";
+import { createRequire } from "node:module";
+import { fs, logger } from "@modern-js/utils";
+export const VIRTUAL_MODULE_BASE = ".MODERN_STORYBOOK";
+export const STORIES_FILENAME = "storybook-stories.js";
+export const STORYBOOK_CONFIG_ENTRY = "storybook-config-entry.js";
+export const requireResolve = (importer, path2) => {
+  const require1 = createRequire(importer);
+  require1.resolve(path2);
+};
+export async function getProvider(bundler, builderConfig) {
+  try {
+    if (bundler === "webpack") {
+      const { builderWebpackProvider } = await import("@modern-js/builder-webpack-provider");
+      return builderWebpackProvider({
+        builderConfig
+      });
+    } else {
+      const { builderRspackProvider } = await import("@modern-js/builder-rspack-provider");
+      return builderRspackProvider({
+        builderConfig
+      });
+    }
+  } catch (e) {
+    logger.error(`Cannot find provider, you need to install @modern-js/builder-${bundler}-provider first`);
+  }
+}
+export async function virtualModule(tempDir, cwd, virtualModuleMap) {
+  fs.ensureDirSync(tempDir);
+  const alias = {};
+  await Promise.all(Reflect.ownKeys(virtualModuleMap).map((k) => {
+    const virtualPath = k;
+    const relativePath = path.relative(cwd, virtualPath);
+    const realPath = path.join(tempDir, relativePath);
+    alias[virtualPath] = realPath;
+    return fs.writeFile(realPath, virtualModuleMap[virtualPath]);
+  }));
+  return [
+    alias,
+    (virtualPath, content) => {
+      const relativePath = path.relative(cwd, virtualPath);
+      const realPath = path.join(tempDir, relativePath);
+      fs.writeFileSync(realPath, content);
+    }
+  ];
+}
+export async function toImportFn(cwd, stories) {
+  const objectEntries = stories.map((file) => {
+    const ext = path.extname(file);
+    const relativePath = path.relative(cwd, file);
+    if (![
+      ".js",
+      ".jsx",
+      ".ts",
+      ".tsx",
+      ".mdx"
+    ].includes(ext)) {
+      logger.warn(`Cannot process ${ext} file with storyStoreV7: ${relativePath}`);
+    }
+    return `  '${toImportPath(relativePath)}': async () => import('${file}')`;
+  });
+  return `
+    const importers = {
+      ${objectEntries.join(",\n")}
+    };
+
+    export async function importFn(path) {
+        return importers[path]();
+    }
+  `;
+}
+function toImportPath(relativePath) {
+  return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
+}
+export function getAbsolutePath(input) {
+  return dirname(require.resolve(join(input, "package.json")));
+}
+export function maybeGetAbsolutePath(input) {
+  try {
+    return getAbsolutePath(input);
+  } catch (e) {
+    return false;
+  }
+}
+export async function runWithErrorMsg(op, msg) {
+  try {
+    return await op();
+  } catch (e) {
+    logger.error(msg);
+    console.error(e);
+  }
+}
+export function isDev() {
+  return process.env.NODE_ENV === "development";
+}

package/dist/types/addons/components/modern.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { Plugin } from '@modern-js/runtime';
+import type { IConfig } from '../type';
+export declare const WrapProviders: (storyFn: any, config: IConfig) => JSX.Element;
+export declare const resolvePlugins: (runtime: IConfig['modernConfigRuntime']) => Plugin[];

package/dist/types/addons/constants.d.ts

@@ -0,0 +1 @@
+export declare const ADDON_ID = "storybook/modern-runtime";

package/dist/types/addons/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/types/addons/preset/preview.d.ts

@@ -0,0 +1 @@
+export declare const decorators: import("@storybook/types").DecoratorFunction[];

package/dist/types/addons/type.d.ts

@@ -0,0 +1,4 @@
+export interface IConfig {
+  modernConfigRuntime: any;
+  modernConfigDesignToken: any;
+}

package/dist/types/addons/withPluginRuntime.d.ts

@@ -0,0 +1,2 @@
+import { DecoratorFunction } from '@storybook/types';
+export declare const withPluginRuntime: DecoratorFunction;

package/dist/types/build.d.ts

@@ -0,0 +1,7 @@
+import type { Builder as RawStorybookBuilder, Stats } from '@storybook/types';
+import type { FrameworkOptions } from './types';
+export type StorybookBuilder = RawStorybookBuilder<FrameworkOptions, Stats>;
+export declare const getConfig: StorybookBuilder['getConfig'];
+export declare const build: StorybookBuilder['build'];
+export declare const start: StorybookBuilder['start'];
+export declare const bail: () => Promise<void>;

package/dist/types/core.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '@storybook/types';
+import type { Compiler } from '@modern-js/utils/webpack-dev-middleware';
+import type { FrameworkOptions } from './types';
+export declare function getCompiler(cwd: string, frameworkConfig: FrameworkOptions, options: Options): Promise<Compiler>;

package/dist/types/docgen/actualNameHandler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This is heavily based on the react-docgen `displayNameHandler`
+ * (https://github.com/reactjs/react-docgen/blob/26c90c0dd105bf83499a83826f2a6ff7a724620d/src/handlers/displayNameHandler.ts)
+ * but instead defines an `actualName` property on the generated docs that is taken first from the component's actual name.
+ * This addresses an issue where the name that the generated docs are stored under is incorrectly named with the `displayName`
+ * and not the component's actual name.
+ *
+ * This is inspired by `actualNameHandler` from https://github.com/storybookjs/babel-plugin-react-docgen, but is modified
+ * directly from displayNameHandler, using the same approach as babel-plugin-react-docgen.
+ */
+import type { NodePath } from 'ast-types/lib/node-path';
+import type { Importer } from 'react-docgen/dist/parse';
+import type Documentation from 'react-docgen/dist/Documentation';
+export default function actualNameHandler(documentation: Documentation, path: NodePath, importer: Importer): void;

package/dist/types/docgen/index.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from '@storybook/types';
+import { RspackConfig } from '@modern-js/builder-rspack-provider';
+import { WebpackChain } from '@modern-js/builder-webpack-provider';
+export type DocgenOptions = {
+  reactDocgen?: 'react-docgen' | 'react-docgen-typescript' | false;
+  reactDocgenTypescriptOptions?: any;
+};
+export declare function applyDocgenWebpack(chain: WebpackChain, options: Options): Promise<void>;
+export declare function applyDocgenRspack(config: RspackConfig, options: Options): Promise<void>;