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

package/dist/cjs/plugin-storybook.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  finalize: function() {
+    return finalize;
+  },
+  pluginStorybook: function() {
+    return pluginStorybook;
+  }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _path = require("path");
+const _utils = require("@modern-js/utils");
+const _buildershared = require("@modern-js/builder-shared");
+const _corecommon = require("@storybook/core-common");
+const _globals = require("@storybook/preview/globals");
+const _csfplugin = require("@storybook/csf-plugin");
+const _minimatch = require("minimatch");
+const _utils1 = require("./utils");
+const _docgen = require("./docgen");
+const STORIES_FILENAME = "storybook-stories.js";
+const STORYBOOK_CONFIG_ENTRY = "storybook-config-entry.js";
+const closeFn = [];
+const onClose = (f) => {
+  closeFn.push(f);
+};
+async function finalize() {
+  await Promise.all([
+    closeFn.map((close) => close())
+  ]);
+}
+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 = (0, _corecommon.normalizeStories)(matchers, {
+        configDir: options.configDir,
+        workingDir: options.configDir
+      }).map(({ directory, files }) => {
+        const pattern = (0, _path.join)(directory, files);
+        const absolutePattern = (0, _path.isAbsolute)(pattern) ? pattern : (0, _path.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 (0, _docgen.applyDocgenWebpack)(chain, options);
+        });
+      } else if ("modifyRspackConfig" in api) {
+        api.modifyRspackConfig(async (config) => {
+          await modifyConfig(config);
+          await (0, _docgen.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.unplugin.rspack(docsOptions) : _csfplugin.unplugin.webpack(docsOptions));
+}
+async function prepareStorybookModules(tempDir, cwd, options, builderConfig, storyPatterns) {
+  var _builderConfig;
+  const mappings = await createStorybookModules(cwd, options, storyPatterns);
+  const componentsPath = (0, _utils1.maybeGetAbsolutePath)(`@storybook/components`);
+  const routerPath = (0, _utils1.maybeGetAbsolutePath)(`@storybook/router`);
+  const themingPath = (0, _utils1.maybeGetAbsolutePath)(`@storybook/theming`);
+  const storybookPaths = {
+    ...componentsPath ? {
+      [`@storybook/components`]: componentsPath
+    } : {},
+    ...routerPath ? {
+      [`@storybook/router`]: routerPath
+    } : {},
+    ...themingPath ? {
+      [`@storybook/theming`]: themingPath
+    } : {}
+  };
+  const [mappingsAlias, write] = await (0, _utils1.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,
+    ...(0, _corecommon.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 Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("remark-external-links")));
+  const remarkSlug = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("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 = (0, _buildershared.mergeBuilderConfig)({
+    output: {
+      externals: (_builderConfig_output = builderConfig.output) === null || _builderConfig_output === void 0 ? void 0 : _builderConfig_output.externals
+    }
+  }, {
+    output: {
+      externals: _globals.globals
+    }
+  });
+  builderConfig.output = config.output;
+}
+function getStoriesEntryPath(cwd) {
+  return (0, _path.resolve)((0, _path.join)(cwd, STORIES_FILENAME));
+}
+function getStoriesConfigPath(cwd) {
+  return (0, _path.resolve)((0, _path.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 (0, _path.resolve)(cwd, (0, _utils.slash)(entry));
+    }),
+    (0, _corecommon.loadPreviewOrConfigFile)(options)
+  ].filter(Boolean);
+  virtualModuleMappings[configEntryPath] = (0, _corecommon.handlebars)(await (0, _corecommon.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 (0, _utils.globby)((0, _utils.slash)(pattern), {
+      followSymbolicLinks: true
+    });
+  }))).reduce((carry, stories2) => carry.concat(stories2), []);
+  return await (0, _utils1.toImportFn)(cwd, stories);
+}
+async function applyReact(config, options) {
+  let version = "18.0.0";
+  try {
+    ({ version } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("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 = (0, _utils.watch)(cwd, async ({ changeType, changedFilePath }) => {
+    if (changeType !== "add" && changeType !== "unlink") {
+      return;
+    }
+    if (patterns.some((entry) => (0, _minimatch.minimatch)(changedFilePath, entry))) {
+      const stories = (await Promise.all(patterns.map((pattern) => {
+        return (0, _utils.globby)((0, _utils.slash)(pattern), {
+          followSymbolicLinks: true
+        });
+      }))).reduce((carry, stories2) => carry.concat(stories2), []);
+      const newStories = await (0, _utils1.toImportFn)(cwd, stories);
+      writeModule(getStoriesEntryPath(cwd), newStories);
+    }
+  }, [
+    /node_modules/
+  ]);
+  return watcher;
+}

package/dist/cjs/preset.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  previewMainTemplate: function() {
+    return previewMainTemplate;
+  },
+  entries: function() {
+    return entries;
+  },
+  modern: function() {
+    return modern;
+  },
+  decorators: function() {
+    return _preview.decorators;
+  }
+});
+const _path = require("path");
+const _build = require("./build");
+const _utils = require("./utils");
+const _preview = require("./addons/preset/preview");
+const previewMainTemplate = () => {
+  return require.resolve("@modern-js/storybook-builder/templates/preview.ejs");
+};
+function getStoriesConfigPath(cwd) {
+  return (0, _path.resolve)((0, _path.join)(cwd, _utils.STORYBOOK_CONFIG_ENTRY));
+}
+const entries = async (_, options) => {
+  const result = [];
+  const { bundler } = await (0, _build.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;
+};
+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
+      }
+    }
+  };
+};

package/dist/cjs/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "defineConfig", {
+  enumerable: true,
+  get: function() {
+    return _cli.defineConfig;
+  }
+});
+const _cli = require("@modern-js/builder/cli");

package/dist/cjs/utils.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  VIRTUAL_MODULE_BASE: function() {
+    return VIRTUAL_MODULE_BASE;
+  },
+  STORIES_FILENAME: function() {
+    return STORIES_FILENAME;
+  },
+  STORYBOOK_CONFIG_ENTRY: function() {
+    return STORYBOOK_CONFIG_ENTRY;
+  },
+  requireResolve: function() {
+    return requireResolve;
+  },
+  getProvider: function() {
+    return getProvider;
+  },
+  virtualModule: function() {
+    return virtualModule;
+  },
+  toImportFn: function() {
+    return toImportFn;
+  },
+  getAbsolutePath: function() {
+    return getAbsolutePath;
+  },
+  maybeGetAbsolutePath: function() {
+    return maybeGetAbsolutePath;
+  },
+  runWithErrorMsg: function() {
+    return runWithErrorMsg;
+  },
+  isDev: function() {
+    return isDev;
+  }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _path = /* @__PURE__ */ _interop_require_wildcard._(require("path"));
+const _nodemodule = require("node:module");
+const _utils = require("@modern-js/utils");
+const VIRTUAL_MODULE_BASE = ".MODERN_STORYBOOK";
+const STORIES_FILENAME = "storybook-stories.js";
+const STORYBOOK_CONFIG_ENTRY = "storybook-config-entry.js";
+const requireResolve = (importer, path) => {
+  const require1 = (0, _nodemodule.createRequire)(importer);
+  require1.resolve(path);
+};
+async function getProvider(bundler, builderConfig) {
+  try {
+    if (bundler === "webpack") {
+      const { builderWebpackProvider } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("@modern-js/builder-webpack-provider")));
+      return builderWebpackProvider({
+        builderConfig
+      });
+    } else {
+      const { builderRspackProvider } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("@modern-js/builder-rspack-provider")));
+      return builderRspackProvider({
+        builderConfig
+      });
+    }
+  } catch (e) {
+    _utils.logger.error(`Cannot find provider, you need to install @modern-js/builder-${bundler}-provider first`);
+  }
+}
+async function virtualModule(tempDir, cwd, virtualModuleMap) {
+  _utils.fs.ensureDirSync(tempDir);
+  const alias = {};
+  await Promise.all(Reflect.ownKeys(virtualModuleMap).map((k) => {
+    const virtualPath = k;
+    const relativePath = _path.default.relative(cwd, virtualPath);
+    const realPath = _path.default.join(tempDir, relativePath);
+    alias[virtualPath] = realPath;
+    return _utils.fs.writeFile(realPath, virtualModuleMap[virtualPath]);
+  }));
+  return [
+    alias,
+    (virtualPath, content) => {
+      const relativePath = _path.default.relative(cwd, virtualPath);
+      const realPath = _path.default.join(tempDir, relativePath);
+      _utils.fs.writeFileSync(realPath, content);
+    }
+  ];
+}
+async function toImportFn(cwd, stories) {
+  const objectEntries = stories.map((file) => {
+    const ext = _path.default.extname(file);
+    const relativePath = _path.default.relative(cwd, file);
+    if (![
+      ".js",
+      ".jsx",
+      ".ts",
+      ".tsx",
+      ".mdx"
+    ].includes(ext)) {
+      _utils.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}`;
+}
+function getAbsolutePath(input) {
+  return (0, _path.dirname)(require.resolve((0, _path.join)(input, "package.json")));
+}
+function maybeGetAbsolutePath(input) {
+  try {
+    return getAbsolutePath(input);
+  } catch (e) {
+    return false;
+  }
+}
+async function runWithErrorMsg(op, msg) {
+  try {
+    return await op();
+  } catch (e) {
+    _utils.logger.error(msg);
+    console.error(e);
+  }
+}
+function isDev() {
+  return process.env.NODE_ENV === "development";
+}

package/dist/esm/addons/components/modern.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createApp } from "@modern-js/runtime";
+import router from "@modern-js/runtime/router";
+import state from "@modern-js/runtime/model";
+export const WrapProviders = (storyFn, config) => {
+  const App = createApp({
+    plugins: resolvePlugins(config.modernConfigRuntime)
+  })(storyFn);
+  return /* @__PURE__ */ _jsx(App, {});
+};
+const allowedRuntimeAPI = {
+  router: "router",
+  state: "state"
+};
+const allowedRuntimeAPIValues = Object.values(allowedRuntimeAPI);
+export const resolvePlugins = (runtime) => {
+  const plugins = [];
+  if (!runtime) {
+    return plugins;
+  }
+  Object.keys(runtime).forEach((api) => {
+    if (allowedRuntimeAPIValues.includes(api)) {
+      if (api === allowedRuntimeAPI.state) {
+        if (typeof runtime.state === "boolean") {
+          if (runtime.state) {
+            plugins.push(state({}));
+          }
+        } else if (typeof runtime.state === "object") {
+          plugins.push(state(runtime.state));
+        }
+      } else if (api === allowedRuntimeAPI.router) {
+        plugins.push(router({
+          ...{
+            serverBase: [
+              "/"
+            ]
+          },
+          ...runtime.router
+        }));
+      }
+    }
+  });
+  return plugins;
+};

package/dist/esm/addons/constants.js

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

package/dist/esm/addons/index.js

@@ -0,0 +1,5 @@
+var _module_hot, _module;
+if ((_module = module) === null || _module === void 0 ? void 0 : (_module_hot = _module.hot) === null || _module_hot === void 0 ? void 0 : _module_hot.decline) {
+  module.hot.decline();
+}
+export default {};

package/dist/esm/addons/preset/preview.js

@@ -0,0 +1,4 @@
+import { withPluginRuntime } from "../withPluginRuntime";
+export const decorators = [
+  withPluginRuntime
+];

package/dist/esm/addons/type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/addons/withPluginRuntime.js

@@ -0,0 +1,10 @@
+import { useParameter } from "@storybook/preview-api";
+import { WrapProviders } from "./components/modern";
+export const withPluginRuntime = (storyFn) => {
+  const modernConfigRuntime = useParameter("modernConfigRuntime");
+  const modernConfigDesignToken = useParameter("modernConfigDesignToken");
+  return WrapProviders(storyFn, {
+    modernConfigRuntime: modernConfigRuntime || {},
+    modernConfigDesignToken
+  });
+};

package/dist/esm/build.js

@@ -0,0 +1,83 @@
+import { dirname, join, parse } from "path";
+import webpackDevMiddleware from "@modern-js/utils/webpack-dev-middleware";
+import webpackHotMiddleware from "webpack-hot-middleware";
+import serveStatic from "serve-static";
+import { fs } from "@modern-js/utils";
+import { getCompiler } from "./core";
+import { finalize } from "./plugin-storybook";
+export const getConfig = async (options) => {
+  var _frameworkOptions;
+  const { presets } = options;
+  const frameworkOptions = await presets.apply("frameworkOptions");
+  return ((_frameworkOptions = frameworkOptions) === null || _frameworkOptions === void 0 ? void 0 : _frameworkOptions.options) || {};
+};
+export const build = async ({ options }) => {
+  const config = await getConfig(options);
+  const compiler = await getCompiler(process.cwd(), config, options);
+  const previewResolvedDir = dirname(require.resolve("@storybook/preview/package.json"));
+  const previewDirOrigin = join(previewResolvedDir, "dist");
+  const previewDirTarget = join(options.outputDir || "", `sb-preview`);
+  const previewFiles = fs.copy(previewDirOrigin, previewDirTarget, {
+    filter: (src) => {
+      const { ext } = parse(src);
+      if (ext) {
+        return ext === ".js";
+      }
+      return true;
+    }
+  });
+  const compilation = new Promise((resolve, reject) => {
+    compiler.run((err, stats2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats2);
+      }
+    });
+  });
+  const [stats] = await Promise.all([
+    compilation,
+    previewFiles
+  ]);
+  return stats;
+};
+export const start = async ({ options, router, startTime }) => {
+  var _config_builderConfig_tools_devServer_devMiddleware, _config_builderConfig_tools_devServer, _config_builderConfig_tools, _config_builderConfig;
+  const previewResolvedDir = dirname(require.resolve("@storybook/preview/package.json"));
+  const previewDirOrigin = join(previewResolvedDir, "dist");
+  router.use(`/sb-preview`, serveStatic(previewDirOrigin, {
+    immutable: true,
+    maxAge: "5m"
+  }));
+  const config = await getConfig(options);
+  const compiler = await getCompiler(process.cwd(), config, options);
+  const middleware = webpackDevMiddleware(compiler, {
+    writeToDisk: ((_config_builderConfig = config.builderConfig) === null || _config_builderConfig === void 0 ? void 0 : (_config_builderConfig_tools = _config_builderConfig.tools) === null || _config_builderConfig_tools === void 0 ? void 0 : (_config_builderConfig_tools_devServer = _config_builderConfig_tools.devServer) === null || _config_builderConfig_tools_devServer === void 0 ? void 0 : (_config_builderConfig_tools_devServer_devMiddleware = _config_builderConfig_tools_devServer.devMiddleware) === null || _config_builderConfig_tools_devServer_devMiddleware === void 0 ? void 0 : _config_builderConfig_tools_devServer_devMiddleware.writeToDisk) || true,
+    // builder can log errors, so not using dev-middleware logs
+    stats: false
+  });
+  router.use(middleware);
+  router.use(webpackHotMiddleware(compiler, {
+    log: false
+  }));
+  const stats = await new Promise((resolve) => {
+    middleware.waitUntilValid((stats2) => {
+      resolve(stats2);
+    });
+  });
+  if (!stats) {
+    throw new Error("build failed");
+  }
+  const statsJson = stats.toJson();
+  if (statsJson.errors.length > 1) {
+    throw stats;
+  }
+  return {
+    bail,
+    stats,
+    totalTime: process.hrtime(startTime)
+  };
+};
+export const bail = async () => {
+  await finalize();
+};