storybook-builder-rsbuild 2.1.5 → 3.0.0-beta.1

package/compiled/@storybook/core-webpack/index.d.ts

@@ -0,0 +1,56 @@
+import { StorybookConfig as StorybookConfig$1, Options, NormalizedStoriesSpecifier } from 'storybook/internal/types';
+export { BuilderResult, Options, Preset, TypescriptOptions } from 'storybook/internal/types';
+
+type RulesConfig = any;
+type ModuleConfig = {
+    rules?: RulesConfig[];
+};
+type ResolveConfig = {
+    extensions?: string[];
+    mainFields?: (string | string[])[] | undefined;
+    alias?: any;
+};
+interface WebpackConfiguration {
+    plugins?: any[];
+    module?: ModuleConfig;
+    resolve?: ResolveConfig;
+    optimization?: any;
+    devtool?: false | string;
+}
+type BuilderOptions = {
+    fsCache?: boolean;
+    lazyCompilation?: boolean;
+};
+type StorybookConfig<TWebpackConfiguration = WebpackConfiguration> = StorybookConfig$1 & {
+    /**
+     * Modify or return a custom Webpack config after the Storybook's default configuration has run
+     * (mostly used by addons).
+     */
+    webpack?: (config: TWebpackConfiguration, options: Options) => TWebpackConfiguration | Promise<TWebpackConfiguration>;
+    /** Modify or return a custom Webpack config after every addon has run. */
+    webpackFinal?: (config: TWebpackConfiguration, options: Options) => TWebpackConfiguration | Promise<TWebpackConfiguration>;
+};
+
+declare const loadCustomWebpackConfig: (configDir: string) => Promise<any>;
+
+declare const checkWebpackVersion: (webpack: {
+    version?: string;
+}, specifier: string, caption: string) => void;
+
+declare function mergeConfigs(config: WebpackConfiguration, customConfig: WebpackConfiguration): WebpackConfiguration;
+
+declare function webpackIncludeRegexp(specifier: NormalizedStoriesSpecifier): RegExp;
+declare function toImportFnPart(specifier: NormalizedStoriesSpecifier): string;
+declare function toImportFn(stories: NormalizedStoriesSpecifier[], { needPipelinedImport }?: {
+    needPipelinedImport?: boolean;
+}): string;
+
+declare const toRequireContext: (specifier: NormalizedStoriesSpecifier) => {
+    path: string;
+    recursive: boolean;
+    match: RegExp;
+};
+declare const toRequireContextString: (specifier: NormalizedStoriesSpecifier) => string;
+
+export { checkWebpackVersion, loadCustomWebpackConfig, mergeConfigs, toImportFn, toImportFnPart, toRequireContext, toRequireContextString, webpackIncludeRegexp };
+export type { BuilderOptions, ModuleConfig, ResolveConfig, RulesConfig, StorybookConfig, WebpackConfiguration };

package/compiled/@storybook/core-webpack/index.js

@@ -0,0 +1,360 @@
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
+import * as __WEBPACK_EXTERNAL_MODULE_storybook_internal_common_7991bda6__ from "storybook/internal/common";
+import * as __WEBPACK_EXTERNAL_MODULE_storybook_internal_node_logger_87de4309__ from "storybook/internal/node-logger";
+var __webpack_modules__ = {
+  980: (__unused_webpack_module, exports) => {
+    var __webpack_unused_export__;
+    __webpack_unused_export__ = { value: true };
+    exports.TW = void 0;
+    function dedent(templ) {
+      var values = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        values[_i - 1] = arguments[_i];
+      }
+      var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+      strings[strings.length - 1] = strings[strings.length - 1].replace(
+        /\r?\n([\t ]*)$/,
+        "",
+      );
+      var indentLengths = strings.reduce(function (arr, str) {
+        var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+        if (matches) {
+          return arr.concat(
+            matches.map(function (match) {
+              var _a, _b;
+              return (_b =
+                (_a = match.match(/[\t ]/g)) === null || _a === void 0
+                  ? void 0
+                  : _a.length) !== null && _b !== void 0
+                ? _b
+                : 0;
+            }),
+          );
+        }
+        return arr;
+      }, []);
+      if (indentLengths.length) {
+        var pattern_1 = new RegExp(
+          "\n[\t ]{" + Math.min.apply(Math, indentLengths) + "}",
+          "g",
+        );
+        strings = strings.map(function (str) {
+          return str.replace(pattern_1, "\n");
+        });
+      }
+      strings[0] = strings[0].replace(/^\r?\n/, "");
+      var string = strings[0];
+      values.forEach(function (value, i) {
+        var endentations = string.match(/(?:^|\n)( *)$/);
+        var endentation = endentations ? endentations[1] : "";
+        var indentedValue = value;
+        if (typeof value === "string" && value.includes("\n")) {
+          indentedValue = String(value)
+            .split("\n")
+            .map(function (str, i) {
+              return i === 0 ? str : "" + endentation + str;
+            })
+            .join("\n");
+        }
+        string += indentedValue + strings[i + 1];
+      });
+      return string;
+    }
+    exports.TW = dedent;
+    __webpack_unused_export__ = dedent;
+  },
+};
+var __webpack_module_cache__ = {};
+function __nccwpck_require__(moduleId) {
+  var cachedModule = __webpack_module_cache__[moduleId];
+  if (cachedModule !== undefined) {
+    return cachedModule.exports;
+  }
+  var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+  var threw = true;
+  try {
+    __webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
+    threw = false;
+  } finally {
+    if (threw) delete __webpack_module_cache__[moduleId];
+  }
+  return module.exports;
+}
+(() => {
+  __nccwpck_require__.d = (exports, definition) => {
+    for (var key in definition) {
+      if (
+        __nccwpck_require__.o(definition, key) &&
+        !__nccwpck_require__.o(exports, key)
+      ) {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          get: definition[key],
+        });
+      }
+    }
+  };
+})();
+(() => {
+  __nccwpck_require__.o = (obj, prop) =>
+    Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+if (typeof __nccwpck_require__ !== "undefined")
+  __nccwpck_require__.ab =
+    new URL(".", import.meta.url).pathname.slice(
+      import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0,
+      -1,
+    ) + "/";
+var __webpack_exports__ = {};
+__nccwpck_require__.d(__webpack_exports__, {
+  il: () => checkWebpackVersion,
+  Tu: () => loadCustomWebpackConfig,
+  SV: () => mergeConfigs,
+  T1: () => toImportFn,
+  i8: () => toImportFnPart,
+  sg: () => toRequireContext,
+  HO: () => toRequireContextString,
+  hO: () => webpackIncludeRegexp,
+});
+const external_node_url_namespaceObject = __WEBPACK_EXTERNAL_createRequire(
+  import.meta.url,
+)("node:url");
+const external_node_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(
+  import.meta.url,
+)("node:path");
+const external_node_module_namespaceObject = __WEBPACK_EXTERNAL_createRequire(
+  import.meta.url,
+)("node:module");
+var x = (y) => {
+  var x = {};
+  __nccwpck_require__.d(x, y);
+  return x;
+};
+var y = (x) => () => x;
+const common_namespaceObject = x({
+  ["globToRegexp"]: () =>
+    __WEBPACK_EXTERNAL_MODULE_storybook_internal_common_7991bda6__.globToRegexp,
+  ["serverRequire"]: () =>
+    __WEBPACK_EXTERNAL_MODULE_storybook_internal_common_7991bda6__.serverRequire,
+});
+var node_logger_x = (y) => {
+  var x = {};
+  __nccwpck_require__.d(x, y);
+  return x;
+};
+var node_logger_y = (x) => () => x;
+const node_logger_namespaceObject = node_logger_x({
+  ["logger"]: () =>
+    __WEBPACK_EXTERNAL_MODULE_storybook_internal_node_logger_87de4309__.logger,
+});
+var dist = __nccwpck_require__(980);
+var dist_filename = external_node_url_namespaceObject.fileURLToPath(
+  import.meta.url,
+);
+var dist_dirname = external_node_path_namespaceObject.dirname(dist_filename);
+var dist_require = external_node_module_namespaceObject.createRequire(
+  import.meta.url,
+);
+var __defProp = Object.defineProperty;
+var __name = (target, value) =>
+  __defProp(target, "name", { value, configurable: true });
+var webpackConfigs = ["webpack.config", "webpackfile"];
+var loadCustomWebpackConfig = __name(
+  async (configDir) =>
+    (0, common_namespaceObject.serverRequire)(
+      webpackConfigs.map((configName) =>
+        (0, external_node_path_namespaceObject.resolve)(configDir, configName),
+      ),
+    ),
+  "loadCustomWebpackConfig",
+);
+var checkWebpackVersion = __name((webpack, specifier, caption) => {
+  if (!webpack.version) {
+    node_logger_namespaceObject.logger.info(
+      "Skipping webpack version check, no version available",
+    );
+    return;
+  }
+  if (webpack.version !== specifier) {
+    node_logger_namespaceObject.logger.warn((0, dist.TW)`
+      Unexpected webpack version in ${caption}:
+      - Received '${webpack.version}'
+      - Expected '${specifier}'
+
+      If you're using Webpack 5 in SB6.2 and upgrading, consider: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#webpack-5-manager-build
+
+      For more info about Webpack 5 support: https://gist.github.com/shilman/8856ea1786dcd247139b47b270912324#troubleshooting
+    `);
+  }
+}, "checkWebpackVersion");
+function mergePluginsField(defaultPlugins = [], customPlugins = []) {
+  return [...defaultPlugins, ...customPlugins];
+}
+__name(mergePluginsField, "mergePluginsField");
+function mergeRulesField(defaultRules = [], customRules = []) {
+  return [...defaultRules, ...customRules];
+}
+__name(mergeRulesField, "mergeRulesField");
+function mergeExtensionsField(
+  { extensions: defaultExtensions = [] },
+  { extensions: customExtensions = [] },
+) {
+  return [...defaultExtensions, ...customExtensions];
+}
+__name(mergeExtensionsField, "mergeExtensionsField");
+function mergeAliasField(
+  { alias: defaultAlias = {} },
+  { alias: customAlias = {} },
+) {
+  return { ...defaultAlias, ...customAlias };
+}
+__name(mergeAliasField, "mergeAliasField");
+function mergeModuleField(a, b) {
+  return { ...a, ...b, rules: mergeRulesField(a.rules || [], b.rules || []) };
+}
+__name(mergeModuleField, "mergeModuleField");
+function mergeResolveField(
+  { resolve: defaultResolve = {} },
+  { resolve: customResolve = {} },
+) {
+  return {
+    ...defaultResolve,
+    ...customResolve,
+    alias: mergeAliasField(defaultResolve, customResolve),
+    extensions: mergeExtensionsField(defaultResolve, customResolve),
+  };
+}
+__name(mergeResolveField, "mergeResolveField");
+function mergeOptimizationField(
+  { optimization: defaultOptimization = {} },
+  { optimization: customOptimization = {} },
+) {
+  return { ...defaultOptimization, ...customOptimization };
+}
+__name(mergeOptimizationField, "mergeOptimizationField");
+function mergeConfigs(config, customConfig) {
+  return {
+    ...customConfig,
+    ...config,
+    devtool: customConfig.devtool || config.devtool,
+    plugins: mergePluginsField(config.plugins, customConfig.plugins),
+    module: mergeModuleField(config.module || {}, customConfig.module || {}),
+    resolve: mergeResolveField(config, customConfig),
+    optimization: mergeOptimizationField(config, customConfig),
+  };
+}
+__name(mergeConfigs, "mergeConfigs");
+function importPipeline() {
+  let importGate = Promise.resolve();
+  return async (importFn) => {
+    await importGate;
+    const moduleExportsPromise = importFn();
+    importGate = importGate.then(async () => {
+      await moduleExportsPromise;
+    });
+    return moduleExportsPromise;
+  };
+}
+__name(importPipeline, "importPipeline");
+function adjustRegexToExcludeNodeModules(originalRegex) {
+  const originalRegexString = originalRegex.source;
+  const startsWithCaret = originalRegexString.startsWith("^");
+  const excludeNodeModulesPattern = startsWithCaret
+    ? "(?!.*node_modules)"
+    : "^(?!.*node_modules)";
+  const adjustedRegexString = startsWithCaret
+    ? `^${excludeNodeModulesPattern}${originalRegexString.substring(1)}`
+    : excludeNodeModulesPattern + originalRegexString;
+  return new RegExp(adjustedRegexString);
+}
+__name(adjustRegexToExcludeNodeModules, "adjustRegexToExcludeNodeModules");
+function webpackIncludeRegexp(specifier) {
+  const { directory, files } = specifier;
+  const directoryWithoutLeadingDots = directory.replace(/^(\.+\/)+/, "/");
+  const webpackIncludeGlob = [".", ".."].includes(directory)
+    ? files
+    : `${directoryWithoutLeadingDots}/${files}`;
+  const webpackIncludeRegexpWithCaret = webpackIncludeGlob.includes(
+    "node_modules",
+  )
+    ? (0, common_namespaceObject.globToRegexp)(webpackIncludeGlob)
+    : adjustRegexToExcludeNodeModules(
+        (0, common_namespaceObject.globToRegexp)(webpackIncludeGlob),
+      );
+  return new RegExp(webpackIncludeRegexpWithCaret.source.replace(/^\^/, ""));
+}
+__name(webpackIncludeRegexp, "webpackIncludeRegexp");
+function toImportFnPart(specifier) {
+  const { directory, importPathMatcher } = specifier;
+  return (0, dist.TW)`
+      async (path) => {
+        if (!${importPathMatcher}.exec(path)) {
+          return;
+        }
+
+        const pathRemainder = path.substring(${directory.length + 1});
+        return import(
+          /* webpackChunkName: "[request]" */
+          /* webpackInclude: ${webpackIncludeRegexp(specifier)} */
+          '${directory}/' + pathRemainder
+        );
+      }
+
+  `;
+}
+__name(toImportFnPart, "toImportFnPart");
+function toImportFn(stories, { needPipelinedImport } = {}) {
+  let pipelinedImport = `const pipeline = (x) => x();`;
+  if (needPipelinedImport) {
+    pipelinedImport = `\n      const importPipeline = ${importPipeline};\n      const pipeline = importPipeline();\n    `;
+  }
+  return (0, dist.TW)`
+    ${pipelinedImport}
+
+    const importers = [
+      ${stories.map(toImportFnPart).join(",\n")}
+    ];
+
+    export async function importFn(path) {
+      for (let i = 0; i < importers.length; i++) {
+        const moduleExports = await pipeline(() => importers[i](path));
+        if (moduleExports) {
+          return moduleExports;
+        }
+      }
+    }
+  `;
+}
+__name(toImportFn, "toImportFn");
+var toRequireContext = __name((specifier) => {
+  const { directory, files } = specifier;
+  const match = (0, common_namespaceObject.globToRegexp)(`./${files}`);
+  return {
+    path: directory,
+    recursive: files.includes("**") || files.split("/").length > 1,
+    match,
+  };
+}, "toRequireContext");
+var toRequireContextString = __name((specifier) => {
+  const { path: p, recursive: r, match: m } = toRequireContext(specifier);
+  const result = `require.context('${p}', ${r}, ${m})`;
+  return result;
+}, "toRequireContextString");
+var __webpack_exports__checkWebpackVersion = __webpack_exports__.il;
+var __webpack_exports__loadCustomWebpackConfig = __webpack_exports__.Tu;
+var __webpack_exports__mergeConfigs = __webpack_exports__.SV;
+var __webpack_exports__toImportFn = __webpack_exports__.T1;
+var __webpack_exports__toImportFnPart = __webpack_exports__.i8;
+var __webpack_exports__toRequireContext = __webpack_exports__.sg;
+var __webpack_exports__toRequireContextString = __webpack_exports__.HO;
+var __webpack_exports__webpackIncludeRegexp = __webpack_exports__.hO;
+export {
+  __webpack_exports__checkWebpackVersion as checkWebpackVersion,
+  __webpack_exports__loadCustomWebpackConfig as loadCustomWebpackConfig,
+  __webpack_exports__mergeConfigs as mergeConfigs,
+  __webpack_exports__toImportFn as toImportFn,
+  __webpack_exports__toImportFnPart as toImportFnPart,
+  __webpack_exports__toRequireContext as toRequireContext,
+  __webpack_exports__toRequireContextString as toRequireContextString,
+  __webpack_exports__webpackIncludeRegexp as webpackIncludeRegexp,
+};

package/compiled/@storybook/core-webpack/package.json

@@ -0,0 +1 @@
+{"name":"@storybook/core-webpack","version":"10.0.7","funding":{"type":"opencollective","url":"https://opencollective.com/storybook"},"license":"MIT","types":"index.d.ts","type":"module"}

package/dist/_node-chunks/chunk-MIMCYZFR.js

@@ -0,0 +1,45 @@
+import CJS_COMPAT_NODE_URL_c7aef05d0183c9d0 from 'node:url';
+import CJS_COMPAT_NODE_PATH_c7aef05d0183c9d0 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_c7aef05d0183c9d0 from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_c7aef05d0183c9d0.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_c7aef05d0183c9d0.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_c7aef05d0183c9d0.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(x, {
+  get: (a, b) => (typeof require < "u" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/index.d.ts

@@ -1,72 +1,3 @@
-import * as rsbuildReal from '@rsbuild/core';
-import { RsbuildConfig } from '@rsbuild/core';
-import { TypescriptOptions as TypescriptOptions$1, Builder, Options, StorybookConfigRaw, BuilderResult as BuilderResult$1 } from 'storybook/internal/types';
-import { PluginTypeCheckerOptions } from '@rsbuild/plugin-type-check';
-
-type RsbuildStats = {
-    toJson: (...args: any[]) => any;
-};
-/**
- * Options for TypeScript usage within Storybook.
- */
-interface TypescriptOptions extends TypescriptOptions$1 {
-    /**
-     * Configures `@rsbuild/plugin-type-check`, using `fork-ts-checker-webpack-plugin` under the hood.
-     */
-    checkOptions?: PluginTypeCheckerOptions;
-}
-type RsbuildBuilder = Builder<RsbuildConfig, RsbuildStats>;
-type RsbuildFinal = (config: RsbuildConfig, options: Options) => RsbuildConfig | Promise<RsbuildConfig>;
-type StorybookConfigRsbuild = {
-    rsbuildFinal?: RsbuildFinal;
-    webpackAddons?: StorybookConfigRaw['addons'];
-};
-type BuilderOptions = {
-    /**
-     * Path to rsbuild.config file, relative to CWD.
-     */
-    rsbuildConfigPath?: string;
-    /**
-     * Enable Rspack's lazy compilation (experimental).
-     */
-    lazyCompilation?: NonNullable<RsbuildConfig['performance']>['buildCache'];
-    /**
-     * Enable Rspack's [persistent cache(experimental)](https://rspack.dev/config/experiments#experimentscache).
-     * We continue to use the name `fsCache` here to maintain better compatibility with the webpack builder.
-     */
-    fsCache?: boolean;
-    /**
-     * Which environment to use from the Rsbuild config.
-     */
-    environment?: string;
-    /**
-     * @storybook/addon-docs options
-     */
-    addonDocs?: any;
-};
-interface BuilderResult extends BuilderResult$1 {
-    stats?: Stats;
-}
-
-declare const getVirtualModules: (options: Options) => Promise<{
-    virtualModules: Record<string, string>;
-    entries: string[];
-}>;
-
-type StatsOrMultiStats = Parameters<rsbuildReal.OnAfterBuildFn>[0]['stats'];
-type Stats = NonNullable<Exclude<StatsOrMultiStats, {
-    stats: unknown[];
-}>>;
-declare const printDuration: (startTime: [number, number]) => string;
-type BuilderStartOptions = Parameters<RsbuildBuilder['start']>['0'];
-declare const executor: {
-    get: (options: Options) => Promise<typeof rsbuildReal>;
-};
-declare const getConfig: RsbuildBuilder['getConfig'];
-declare function bail(): Promise<void>;
-declare const start: RsbuildBuilder['start'];
-declare const build: ({ options }: BuilderStartOptions) => Promise<Stats>;
-declare const corePresets: string[];
-declare const previewMainTemplate: () => string;
-
-export { BuilderOptions, BuilderResult, RsbuildBuilder, RsbuildFinal, Stats, StorybookConfigRsbuild, TypescriptOptions, bail, build, corePresets, executor, getConfig, getVirtualModules, previewMainTemplate, printDuration, start };
+// auto generated file from file:///Users/bytedance/Projects/storybook-rsbuild/scripts/build/utils/generate-type-mappers.ts, do not edit
+export * from '../src/index.ts';
+export type * from '../src/index.ts';