vite-plugin-storybook-nextjs 0.0.13--canary.8.d70ae00.0 → 0.0.13--canary.8.c64d6ac.0

package/dist/index.cjs

@@ -0,0 +1,934 @@
+'use strict';
+
+var path = require('path');
+var module$1 = require('module');
+var defineEnvPlugin_js = require('next/dist/build/webpack/plugins/define-env-plugin.js');
+var fs3 = require('fs');
+var env = require('@next/env');
+var Log = require('next/dist/build/output/log.js');
+var index_js = require('next/dist/build/swc/index.js');
+var constants_js = require('next/dist/shared/lib/constants.js');
+var fs2 = require('fs/promises');
+var fetchCssFromGoogleFonts_js = require('next/dist/compiled/@next/font/dist/google/fetch-css-from-google-fonts.js');
+var getFontAxes_js = require('next/dist/compiled/@next/font/dist/google/get-font-axes.js');
+var getGoogleFontsUrl_js = require('next/dist/compiled/@next/font/dist/google/get-google-fonts-url.js');
+var validateGoogleFontFunctionCall_js = require('next/dist/compiled/@next/font/dist/google/validate-google-font-function-call.js');
+var loaderUtils = require('next/dist/compiled/loader-utils3/index.js');
+var validateLocalFontFunctionCall_js = require('next/dist/compiled/@next/font/dist/local/validate-local-font-function-call.js');
+var tsDedent = require('ts-dedent');
+var loadJsConfig = require('next/dist/build/load-jsconfig.js');
+var findPagesDir_js = require('next/dist/lib/find-pages-dir.js');
+var utils_js = require('next/dist/build/utils.js');
+var options_js = require('next/dist/build/swc/options.js');
+var loadConfig = require('next/dist/server/config.js');
+var os = require('os');
+var querystring = require('querystring');
+var imageSizeOf = require('image-size');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var Log__default = /*#__PURE__*/_interopDefault(Log);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var loaderUtils__default = /*#__PURE__*/_interopDefault(loaderUtils);
+var loadJsConfig__default = /*#__PURE__*/_interopDefault(loadJsConfig);
+var loadConfig__default = /*#__PURE__*/_interopDefault(loadConfig);
+var imageSizeOf__default = /*#__PURE__*/_interopDefault(imageSizeOf);
+
+// src/index.ts
+var nextDistPath = /(next[\\/]dist[\\/]shared[\\/]lib)|(next[\\/]dist[\\/]client)|(next[\\/]dist[\\/]pages)/;
+async function loadEnvironmentConfig(dir, dev) {
+  return env.loadEnvConfig(dir, dev, Log__default.default);
+}
+async function loadSWCBindingsEagerly(nextConfig) {
+  await index_js.loadBindings(nextConfig?.experimental?.useWasmBinary);
+  if (index_js.lockfilePatchPromise.cur) {
+    await index_js.lockfilePatchPromise.cur;
+  }
+}
+function shouldOutputCommonJs(filename) {
+  return filename.endsWith(".cjs") || nextDistPath.test(filename);
+}
+async function loadClosestPackageJson(dir, attempts = 1) {
+  if (attempts > 5) {
+    throw new Error("Can't resolve main package.json file");
+  }
+  const mainPath = attempts === 1 ? ["."] : new Array(attempts).fill("..");
+  try {
+    const file = await fs3__default.default.promises.readFile(
+      path.join(dir, ...mainPath, "package.json"),
+      "utf8"
+    );
+    return JSON.parse(file);
+  } catch (e) {
+    return loadClosestPackageJson(dir, attempts + 1);
+  }
+}
+
+// src/plugins/next-env/plugin.ts
+function vitePluginNextEnv(rootDir, nextConfigResolver) {
+  let envConfig;
+  let isDev;
+  const resolvedDir = path.resolve(rootDir);
+  return {
+    name: "vite-plugin-storybook-nextjs-env",
+    enforce: "pre",
+    async config(config, env) {
+      isDev = env.mode !== "production";
+      envConfig = (await loadEnvironmentConfig(resolvedDir, isDev)).combinedEnv;
+      const nextConfig = await nextConfigResolver.promise;
+      const publicNextEnvMap = Object.fromEntries(
+        Object.entries(envConfig).filter(([key]) => key.startsWith("NEXT_PUBLIC_")).map(([key, value]) => {
+          return [`process.env.${key}`, JSON.stringify(value)];
+        })
+      );
+      const finalConfig = {
+        ...config.define,
+        ...publicNextEnvMap,
+        ...defineEnvPlugin_js.getDefineEnv({
+          isTurbopack: false,
+          config: nextConfig,
+          isClient: true,
+          isEdgeServer: false,
+          isNodeOrEdgeCompilation: false,
+          isNodeServer: false,
+          clientRouterFilters: void 0,
+          dev: isDev,
+          middlewareMatchers: void 0,
+          hasRewrites: false,
+          distDir: nextConfig.distDir,
+          fetchCacheKeyPrefix: nextConfig?.experimental?.fetchCacheKeyPrefix
+        })
+      };
+      delete process.env.__NEXT_IMAGE_OPTS;
+      delete finalConfig["process.env.__NEXT_IMAGE_OPTS"];
+      return {
+        define: finalConfig,
+        test: {
+          deps: {
+            optimizer: {
+              ssr: {
+                include: ["next"]
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+}
+var cssCache = /* @__PURE__ */ new Map();
+async function getFontFaceDeclarations(options) {
+  const {
+    fontFamily,
+    weights,
+    styles,
+    selectedVariableAxes,
+    display,
+    variable
+  } = validateGoogleFontFunctionCall_js.validateGoogleFontFunctionCall(options.fontFamily, options.props);
+  const fontAxes = getFontAxes_js.getFontAxes(
+    fontFamily,
+    weights,
+    styles,
+    selectedVariableAxes
+  );
+  const url = getGoogleFontsUrl_js.getGoogleFontsUrl(fontFamily, fontAxes, display);
+  try {
+    const hasCachedCSS = cssCache.has(url);
+    const fontFaceCSS = hasCachedCSS ? cssCache.get(url) : await fetchCssFromGoogleFonts_js.fetchCSSFromGoogleFonts(url, fontFamily, true).catch(() => null);
+    if (!hasCachedCSS) {
+      cssCache.set(url, fontFaceCSS);
+    } else {
+      cssCache.delete(url);
+    }
+    if (fontFaceCSS === null) {
+      throw new Error(
+        `Failed to fetch \`${fontFamily}\` from Google Fonts with URL: \`${url}\``
+      );
+    }
+    return {
+      id: loaderUtils__default.default.getHashDigest(url, "md5", "hex", 6),
+      fontFamily,
+      fontFaceCSS,
+      weights,
+      styles,
+      variable
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to fetch \`${fontFamily}\` from Google Fonts with URL: \`${url}\``
+    );
+  }
+}
+var getPlaceholderFontUrl = (refId) => `__%%import.meta.ROLLUP_FILE_URL_${refId}%%__`;
+getPlaceholderFontUrl.regexp = /__%%import\.meta\.ROLLUP_FILE_URL_(.*?)%%__/g;
+async function getFontFaceDeclarations2(options) {
+  const localFontSrc = options.props.metaSrc;
+  const {
+    weight,
+    style,
+    variable,
+    declarations = []
+  } = validateLocalFontFunctionCall_js.validateLocalFontFunctionCall("", options.props);
+  const id = `font-${loaderUtils__default.default.getHashDigest(
+    Buffer.from(JSON.stringify(localFontSrc)),
+    "md5",
+    "hex",
+    6
+  )}`;
+  const fontDeclarations = declarations.map(
+    ({ prop, value }) => `${prop}: ${value};`
+  ).join("\n");
+  const getFontFaceCSS = () => {
+    if (localFontSrc) {
+      if ("fontReferenceId" in localFontSrc) {
+        return tsDedent.dedent`@font-face {
+					font-family: ${id};
+					src: url(${localFontSrc.fontReferenceId ? getPlaceholderFontUrl(localFontSrc.fontReferenceId) : `/@fs${localFontSrc.fontPath}`})
+					${fontDeclarations}
+				}`;
+      }
+      return localFontSrc.map((font) => {
+        return tsDedent.dedent`@font-face {
+						font-family: ${id};
+						src: url(${font.path.fontReferenceId ? getPlaceholderFontUrl(font.path.fontReferenceId) : `/@fs${font.path.fontPath}`});
+						${font.weight ? `font-weight: ${font.weight};` : ""}
+						${font.style ? `font-style: ${font.style};` : ""}
+						${fontDeclarations}
+					}`;
+      }).join("");
+    }
+    return "";
+  };
+  return {
+    id,
+    fontFamily: id,
+    fontFaceCSS: getFontFaceCSS(),
+    weights: weight ? [weight] : [],
+    styles: style ? [style] : [],
+    variable
+  };
+}
+
+// src/plugins/next-font/utils/get-css-meta.ts
+function getCSSMeta(options) {
+  const className = getClassName(options);
+  const style = getStylesObj(options);
+  const variableClassName = `__variable_${className}`;
+  const classNamesCSS = `
+    .${className} {
+      font-family: ${options.fontFamily};
+      ${isNextCSSPropertyValid(options.styles) ? `font-style: ${options.styles[0]};` : ""}
+      ${isNextCSSPropertyValid(options.weights) ? `font-weight: ${options.weights[0]};` : ""}
+    }
+
+    ${options.variable ? `.${variableClassName} { ${options.variable}: '${options.fontFamily}'; }` : ""}
+  `;
+  const fontFaceCSS = `${changeFontDisplayToSwap(options.fontFaceCSS)}`;
+  return {
+    className,
+    fontFaceCSS,
+    classNamesCSS,
+    style,
+    ...options.variable ? { variableClassName } : {}
+  };
+}
+function getClassName({ styles, weights, fontFamily }) {
+  const font = fontFamily.replaceAll(" ", "-").toLowerCase();
+  const style = isNextCSSPropertyValid(styles) ? styles[0] : null;
+  const weight = isNextCSSPropertyValid(weights) ? weights[0] : null;
+  return `${font}${style ? `-${style}` : ""}${weight ? `-${weight}` : ""}`;
+}
+function getStylesObj({ styles, weights, fontFamily }) {
+  return {
+    fontFamily,
+    ...isNextCSSPropertyValid(styles) ? { fontStyle: styles[0] } : {},
+    ...isNextCSSPropertyValid(weights) ? { fontWeight: weights[0] } : {}
+  };
+}
+function isNextCSSPropertyValid(prop) {
+  return prop.length === 1 && prop[0] !== "variable";
+}
+function changeFontDisplayToSwap(css) {
+  return css.replaceAll("font-display: optional;", "font-display: block;");
+}
+function setFontDeclarationsInHead({
+  id,
+  fontFaceCSS,
+  classNamesCSS
+}) {
+  const regex = new RegExp(getPlaceholderFontUrl.regexp);
+  const fontPaths = fontFaceCSS.matchAll(regex);
+  const fontPathsImportUrls = [];
+  if (fontPaths) {
+    for (const match of fontFaceCSS.matchAll(regex)) {
+      fontPathsImportUrls.push({
+        id: match[1],
+        path: match[0].replaceAll(/__%%|%%__/g, "")
+      });
+    }
+  }
+  return tsDedent.dedent`
+  const fontPaths = [${fontPathsImportUrls.map((fontPath) => `{id: '${fontPath.id}', path: ${fontPath.path}}`).join(", ")}];
+  if (!document.getElementById('id-${id}')) {
+    let fontDeclarations = \`${fontFaceCSS}\`;
+    fontPaths.forEach((fontPath, i) => {
+      fontDeclarations = fontDeclarations.replace('__%%import.meta.ROLLUP_FILE_URL_' + fontPath.id + '%%__', fontPath.path.toString());
+    });
+    const style = document.createElement('style');
+    style.setAttribute('id', 'font-face-${id}');
+    style.innerHTML = fontDeclarations;
+    document.head.appendChild(style);
+
+    const classNamesCSS = \`${classNamesCSS}\`;
+    const classNamesStyle = document.createElement('style');
+    classNamesStyle.setAttribute('id', 'classnames-${id}');
+    classNamesStyle.innerHTML = classNamesCSS;
+    document.head.appendChild(classNamesStyle);
+  }
+`;
+}
+
+// src/plugins/next-font/plugin.ts
+var includePattern = /next(\\|\/|\\\\).*(\\|\/|\\\\)target\.css.*$/;
+var virtualModuleId = "virtual:next-font";
+function vitePluginNextFont() {
+  let devMode = true;
+  return {
+    name: "vite-plugin-storybook-nextjs-font",
+    enforce: "pre",
+    async config(config, env) {
+      devMode = env.mode !== "production";
+      return config;
+    },
+    async resolveId(source, importer) {
+      const cwd = process.cwd();
+      if (!includePattern.test(source) || !importer) {
+        return null;
+      }
+      const [sourceWithoutQuery, rawQuery] = source.split("?");
+      const queryParams = JSON.parse(rawQuery);
+      const fontOptions = {
+        filename: queryParams.path ?? "",
+        fontFamily: queryParams.import ?? "",
+        props: queryParams.arguments?.[0] ?? {},
+        source: importer
+      };
+      if (fontOptions.source.endsWith("html")) {
+        return null;
+      }
+      let fontFaceDeclaration;
+      const pathSep = path__default.default.sep;
+      if (sourceWithoutQuery.endsWith(
+        ["next", "font", "google", "target.css"].join(pathSep)
+      )) {
+        fontFaceDeclaration = await getFontFaceDeclarations(fontOptions);
+      }
+      if (sourceWithoutQuery.endsWith(
+        ["next", "font", "local", "target.css"].join(pathSep)
+      )) {
+        const importerDirPath = path__default.default.dirname(fontOptions.filename);
+        const emitFont = async (importerRelativeFontPath) => {
+          const fontExtension = path__default.default.extname(importerRelativeFontPath);
+          const fontBaseName = path__default.default.basename(
+            importerRelativeFontPath,
+            fontExtension
+          );
+          const fontPath = path__default.default.join(importerDirPath, importerRelativeFontPath);
+          if (devMode) {
+            return {
+              fontPath: path__default.default.join(cwd, fontPath),
+              fontReferenceId: void 0
+            };
+          }
+          try {
+            const fontData = await fs2__default.default.readFile(fontPath);
+            const fontReferenceId = this.emitFile({
+              name: `${fontBaseName}${fontExtension}`,
+              type: "asset",
+              source: fontData
+            });
+            return { fontReferenceId, fontPath };
+          } catch (err) {
+            console.error(`Could not read font file ${fontPath}:`, err);
+            return void 0;
+          }
+        };
+        const loaderOptions = {
+          ...fontOptions
+        };
+        if (loaderOptions) {
+          if (typeof fontOptions.props.src === "string") {
+            const font = await emitFont(fontOptions.props.src);
+            loaderOptions.props.metaSrc = font;
+          } else {
+            loaderOptions.props.metaSrc = (await Promise.all(
+              (fontOptions.props.src ?? []).map(async (fontSrc) => {
+                const font = await emitFont(fontSrc.path);
+                if (!font) {
+                  return void 0;
+                }
+                return {
+                  ...fontSrc,
+                  path: font
+                };
+              })
+            )).filter((font) => font !== void 0);
+          }
+        }
+        fontFaceDeclaration = await getFontFaceDeclarations2(loaderOptions);
+      }
+      return {
+        id: `${virtualModuleId}?${rawQuery}`,
+        meta: {
+          fontFaceDeclaration
+        }
+      };
+    },
+    load(id) {
+      const [source] = id.split("?");
+      if (source !== virtualModuleId) {
+        return void 0;
+      }
+      const moduleInfo = this.getModuleInfo(id);
+      const fontFaceDeclaration = moduleInfo?.meta?.fontFaceDeclaration;
+      if (typeof fontFaceDeclaration !== "undefined") {
+        const cssMeta = getCSSMeta(fontFaceDeclaration);
+        return `
+				${setFontDeclarationsInHead({
+          fontFaceCSS: cssMeta.fontFaceCSS,
+          id: fontFaceDeclaration.id,
+          classNamesCSS: cssMeta.classNamesCSS
+        })}
+			
+				export default {
+				  className: "${cssMeta.className}", 
+				  style: ${JSON.stringify(cssMeta.style)}
+				  ${cssMeta.variableClassName ? `, variable: "${cssMeta.variableClassName}"` : ""}
+				}
+				`;
+      }
+      return "export default {}";
+    }
+  };
+}
+
+// src/utils/swc/styles.ts
+function getStyledComponentsOptions(styledComponentsConfig, development) {
+  if (!styledComponentsConfig) {
+    return null;
+  }
+  if (typeof styledComponentsConfig === "object") {
+    return {
+      ...styledComponentsConfig,
+      displayName: styledComponentsConfig.displayName ?? Boolean(development)
+    };
+  }
+  return {
+    displayName: Boolean(development)
+  };
+}
+function getEmotionOptions(emotionConfig, development) {
+  if (!emotionConfig) {
+    return null;
+  }
+  let autoLabel = !!development;
+  switch (typeof emotionConfig === "object" && emotionConfig.autoLabel) {
+    case "never":
+      autoLabel = false;
+      break;
+    case "always":
+      autoLabel = true;
+      break;
+  }
+  return {
+    enabled: true,
+    autoLabel,
+    sourcemap: development,
+    ...typeof emotionConfig === "object" && {
+      importMap: emotionConfig.importMap,
+      labelFormat: emotionConfig.labelFormat,
+      sourcemap: development && emotionConfig.sourceMap
+    }
+  };
+}
+
+// src/utils/swc/options.ts
+var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+var regeneratorRuntimePath = require2.resolve(
+  "next/dist/compiled/regenerator-runtime"
+);
+function getBaseSWCOptions({
+  filename,
+  development,
+  hasReactRefresh,
+  globalWindow,
+  esm,
+  modularizeImports,
+  swcPlugins,
+  compilerOptions,
+  resolvedBaseUrl,
+  jsConfig,
+  swcCacheDir
+}) {
+  const parserConfig = options_js.getParserOptions({ filename, jsConfig });
+  const paths = jsConfig?.compilerOptions?.paths;
+  const enableDecorators = Boolean(
+    jsConfig?.compilerOptions?.experimentalDecorators
+  );
+  const emitDecoratorMetadata = Boolean(
+    jsConfig?.compilerOptions?.emitDecoratorMetadata
+  );
+  const useDefineForClassFields = Boolean(
+    jsConfig?.compilerOptions?.useDefineForClassFields
+  );
+  const plugins = (swcPlugins ?? []).filter(Array.isArray).map(([name, options]) => [require2.resolve(name), options]);
+  return {
+    jsc: {
+      ...resolvedBaseUrl && paths ? {
+        baseUrl: resolvedBaseUrl.baseUrl,
+        paths
+      } : {},
+      externalHelpers: false,
+      parser: parserConfig,
+      experimental: {
+        keepImportAttributes: true,
+        emitAssertForImportAttributes: true,
+        plugins,
+        cacheRoot: swcCacheDir
+      },
+      transform: {
+        legacyDecorator: enableDecorators,
+        decoratorMetadata: emitDecoratorMetadata,
+        useDefineForClassFields,
+        react: {
+          importSource: jsConfig?.compilerOptions?.jsxImportSource ?? (compilerOptions?.emotion ? "@emotion/react" : "react"),
+          runtime: "automatic",
+          pragmaFrag: "React.Fragment",
+          throwIfNamespace: true,
+          development: !!development,
+          useBuiltins: true,
+          refresh: !!hasReactRefresh
+        },
+        optimizer: {
+          simplify: false,
+          // TODO: Figuring out for what globals are exactly used for
+          globals: {
+            typeofs: {
+              window: globalWindow ? "object" : "undefined"
+            },
+            envs: {
+              NODE_ENV: development ? '"development"' : '"production"'
+            }
+          }
+        },
+        regenerator: {
+          importPath: regeneratorRuntimePath
+        }
+      }
+    },
+    sourceMaps: true,
+    removeConsole: compilerOptions?.removeConsole,
+    reactRemoveProperties: false,
+    // Map the k-v map to an array of pairs.
+    modularizeImports: modularizeImports ? Object.fromEntries(
+      Object.entries(modularizeImports).map(([mod, config]) => [
+        mod,
+        {
+          ...config,
+          transform: typeof config.transform === "string" ? config.transform : Object.entries(config.transform).map(([key, value]) => [
+            key,
+            value
+          ])
+        }
+      ])
+    ) : void 0,
+    relay: compilerOptions?.relay,
+    // Always transform styled-jsx and error when `client-only` condition is triggered
+    styledJsx: {},
+    // Disable css-in-js libs (without client-only integration) transform on server layer for server components
+    emotion: getEmotionOptions(compilerOptions?.emotion, development),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    styledComponents: getStyledComponentsOptions(
+      compilerOptions?.styledComponents,
+      development
+    ),
+    serverComponents: void 0,
+    serverActions: void 0,
+    // For app router we prefer to bundle ESM,
+    // On server side of pages router we prefer CJS.
+    preferEsm: esm
+  };
+}
+
+// src/utils/swc/transform.ts
+var getVitestSWCTransformConfig = ({
+  filename,
+  inputSourceMap,
+  isServerEnvironment,
+  loadedJSConfig,
+  nextDirectories,
+  nextConfig,
+  rootDir,
+  isDev,
+  isEsmProject
+}) => {
+  const baseOptions = getBaseSWCOptions({
+    filename,
+    development: isDev,
+    hasReactRefresh: false,
+    globalWindow: !isServerEnvironment,
+    modularizeImports: nextConfig.modularizeImports,
+    jsConfig: loadedJSConfig.jsConfig,
+    resolvedBaseUrl: loadedJSConfig.resolvedBaseUrl,
+    swcPlugins: nextConfig.experimental.swcPlugins,
+    compilerOptions: nextConfig?.compilerOptions,
+    esm: isEsmProject,
+    swcCacheDir: path__default.default.join(
+      rootDir,
+      nextConfig.distDir ?? ".next",
+      "cache",
+      "swc"
+    )
+  });
+  const useCjsModules = shouldOutputCommonJs(filename);
+  const isPageFile = nextDirectories.pagesDir ? filename.startsWith(nextDirectories.pagesDir) : false;
+  return {
+    ...baseOptions,
+    fontLoaders: {
+      fontLoaders: ["next/font/local", "next/font/google"],
+      relativeFilePathFromRoot: path__default.default.relative(rootDir, filename)
+    },
+    cjsRequireOptimizer: {
+      packages: {
+        "next/server": {
+          transforms: {
+            NextRequest: "next/dist/server/web/spec-extension/request",
+            NextResponse: "next/dist/server/web/spec-extension/response",
+            ImageResponse: "next/dist/server/web/spec-extension/image-response",
+            userAgentFromString: "next/dist/server/web/spec-extension/user-agent",
+            userAgent: "next/dist/server/web/spec-extension/user-agent"
+          }
+        }
+      }
+    },
+    ...isServerEnvironment ? {
+      env: {
+        targets: {
+          // Targets the current version of Node.js
+          node: process.versions.node
+        }
+      }
+    } : {
+      env: {
+        targets: utils_js.getSupportedBrowsers(rootDir, isDev)
+      }
+    },
+    module: {
+      type: isEsmProject && !useCjsModules ? "es6" : "commonjs"
+    },
+    disableNextSsg: !isPageFile,
+    disablePageConfig: true,
+    isPageFile,
+    pagesDir: nextDirectories.pagesDir,
+    appDir: nextDirectories.appDir,
+    isDevelopment: isDev,
+    isServerCompiler: isServerEnvironment,
+    inputSourceMap: inputSourceMap && typeof inputSourceMap === "object" ? JSON.stringify(inputSourceMap) : void 0,
+    sourceFileName: filename,
+    filename
+  };
+};
+
+// src/utils/typescript.ts
+var isDefined = (value) => value !== void 0;
+
+// src/plugins/next-swc/plugin.ts
+var excluded = /[\\/](cache[\\/][^\\/]+\.zip[\\/]node_modules|virtual:)[\\/]/g;
+var included = /\.((c|m)?(j|t)sx?)$/;
+function vitePluginNextSwc(rootDir, nextConfigResolver) {
+  let loadedJSConfig;
+  let nextDirectories;
+  let isServerEnvironment;
+  let isDev;
+  let isEsmProject;
+  const resolvedDir = path.resolve(rootDir);
+  return {
+    name: "vite-plugin-storybook-nextjs-swc",
+    enforce: "pre",
+    async config(config, env) {
+      const nextConfig = await nextConfigResolver.promise;
+      nextDirectories = findPagesDir_js.findPagesDir(resolvedDir);
+      loadedJSConfig = await loadJsConfig__default.default(resolvedDir, nextConfig);
+      isDev = env.mode !== "production";
+      await loadClosestPackageJson(resolvedDir);
+      isEsmProject = true;
+      await loadSWCBindingsEagerly(nextConfig);
+      const serverWatchIgnored = config.server?.watch?.ignored;
+      const isServerWatchIgnoredArray = Array.isArray(serverWatchIgnored);
+      if (config.test?.environment === "node" || config.test?.environment === "edge-runtime" || config.test?.browser?.enabled !== false) {
+        isServerEnvironment = true;
+      }
+      return {
+        // esbuild: {
+        //   // We will use Next.js custom SWC transpiler instead of Vite's build-in esbuild
+        //   exclude: [/node_modules/, /.m?(t|j)sx?/],
+        // },
+        server: {
+          watch: {
+            ignored: [
+              ...isServerWatchIgnoredArray ? serverWatchIgnored : [serverWatchIgnored],
+              "/.next/"
+            ].filter(isDefined)
+          }
+        }
+      };
+    },
+    async transform(code, id) {
+      if (!excluded.test(id) && included.test(id)) {
+        const inputSourceMap = this.getCombinedSourcemap();
+        const output = await index_js.transform(
+          code,
+          getVitestSWCTransformConfig({
+            filename: id,
+            inputSourceMap,
+            isServerEnvironment,
+            loadedJSConfig,
+            nextConfig: await nextConfigResolver.promise,
+            nextDirectories,
+            rootDir,
+            isDev,
+            isEsmProject
+          })
+        );
+        return output;
+      }
+    }
+  };
+}
+
+// src/polyfills/promise-with-resolvers.ts
+if (typeof Promise.withResolvers === "undefined") {
+  Promise.withResolvers = () => {
+    let resolve4;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve4 = res;
+      reject = rej;
+    });
+    return { promise, resolve: resolve4, reject };
+  };
+}
+
+// src/utils.ts
+var VITEST_PLUGIN_NAME = "vite-plugin-storybook-nextjs";
+var isVitestEnv = process.env.VITEST === "true";
+
+// src/plugins/next-image/plugin.ts
+var includePattern2 = /\.(png|jpg|jpeg|gif|webp|avif|ico|bmp|svg)$/;
+var excludeImporterPattern = /\.(css|scss|sass)$/;
+var virtualImage = "virtual:next-image";
+var virtualNextImage = "virtual:next/image";
+var virtualNextLegacyImage = "virtual:next/legacy/image";
+var sharp;
+var require3 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+try {
+  sharp = require3("sharp");
+  if (sharp && sharp.concurrency() > 1) {
+    const divisor = process.env.NODE_ENV === "development" ? 4 : 2;
+    sharp.concurrency(Math.floor(Math.max(os.cpus().length / divisor, 1)));
+  }
+} catch (e) {
+  console.warn(
+    "You have to install sharp in order to use image optimization features in Next.js. AVIF support is also disabled."
+  );
+}
+var getEntryPoint = (subPath, env) => require3.resolve(`${VITEST_PLUGIN_NAME}/${env}/mocks/${subPath}`);
+var getAlias = (env) => ({
+  "sb-original/default-loader": getEntryPoint("image-default-loader", env),
+  "sb-original/image-context": getEntryPoint("image-context", env)
+});
+function vitePluginNextImage(nextConfigResolver) {
+  let isBrowser = !isVitestEnv;
+  return {
+    name: "vite-plugin-storybook-nextjs-image",
+    enforce: "pre",
+    async config(config, env) {
+      if (config.test?.browser?.enabled === true) {
+        isBrowser = true;
+      }
+      return {
+        resolve: {
+          alias: getAlias(isBrowser ? "browser" : "node")
+        }
+      };
+    },
+    async resolveId(id, importer) {
+      const [source, queryA] = id.split("?");
+      if (queryA === "ignore") {
+        return null;
+      }
+      if (includePattern2.test(source) && !excludeImporterPattern.test(importer ?? "") && !importer?.startsWith(virtualImage)) {
+        const isAbsolute = path__default.default.isAbsolute(id);
+        const imagePath = importer ? isAbsolute ? source : path__default.default.join(path__default.default.dirname(importer), source) : source;
+        return `${virtualImage}?imagePath=${imagePath}`;
+      }
+      if (id === "next/image" && importer !== virtualNextImage) {
+        return virtualNextImage;
+      }
+      if (id === "next/legacy/image" && importer !== virtualNextLegacyImage) {
+        return virtualNextLegacyImage;
+      }
+      return null;
+    },
+    async load(id) {
+      const aliasEnv = isBrowser ? "browser" : "node";
+      if (virtualNextImage === id) {
+        return (await fs3__default.default.promises.readFile(
+          require3.resolve(`${VITEST_PLUGIN_NAME}/${aliasEnv}/mocks/image`)
+        )).toString("utf-8");
+      }
+      if (virtualNextLegacyImage === id) {
+        return (await fs3__default.default.promises.readFile(
+          require3.resolve(
+            `${VITEST_PLUGIN_NAME}/${aliasEnv}/mocks/legacy-image`
+          )
+        )).toString("utf-8");
+      }
+      const [source, query] = id.split("?");
+      if (virtualImage === source) {
+        const imagePath = querystring.decode(query).imagePath;
+        const nextConfig = await nextConfigResolver.promise;
+        const extension = path__default.default.extname(imagePath);
+        try {
+          if (nextConfig.images?.disableStaticImages) {
+            return tsDedent.dedent`
+						import image from "${imagePath}?ignore";
+						export default image;
+					`;
+          }
+          const imageData = await fs3__default.default.promises.readFile(imagePath);
+          let width;
+          let height;
+          if (extension === ".avif" && sharp) {
+            const transformer = sharp(Buffer.from(imageData));
+            const result = await transformer.metadata();
+            width = result.width;
+            height = result.height;
+          } else {
+            const result = imageSizeOf__default.default(imageData);
+            width = result.width;
+            height = result.height;
+          }
+          return tsDedent.dedent`
+						import src from "${imagePath}?ignore";
+						export default {
+							src,
+							height: ${height},
+							width: ${width},
+							blurDataURL: src
+						};
+					`;
+        } catch (err) {
+          console.error(`Could not read font file ${imagePath}:`, err);
+          return void 0;
+        }
+      }
+      return null;
+    }
+  };
+}
+var require4 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+var getEntryPoint2 = (subPath, env) => require4.resolve(`${VITEST_PLUGIN_NAME}/${env}/mocks/${subPath}`);
+var getAlias2 = (env) => ({
+  "next/headers": getEntryPoint2("headers", env),
+  "@storybook/nextjs/headers.mock": getEntryPoint2("headers", env),
+  "next/navigation": getEntryPoint2("navigation", env),
+  "@storybook/nextjs/navigation.mock": getEntryPoint2("navigation", env),
+  "next/router": getEntryPoint2("router", env),
+  "@storybook/nextjs/router.mock": getEntryPoint2("router", env),
+  "next/cache": getEntryPoint2("cache", env),
+  "@storybook/nextjs/cache.mock": getEntryPoint2("cache", env),
+  "server-only": getEntryPoint2("server-only", env),
+  "@opentelemetry/api": require4.resolve(
+    "next/dist/compiled/@opentelemetry/api/index.js"
+  )
+});
+var vitePluginNextMocks = () => ({
+  name: "vite-plugin-next-mocks",
+  config: (env) => {
+    const aliasEnv = isVitestEnv && env.test?.browser?.enabled !== true ? "node" : "browser";
+    return {
+      resolve: {
+        alias: getAlias2(aliasEnv)
+      }
+    };
+  }
+});
+
+// src/index.ts
+var require5 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+function VitePlugin({ dir = process.cwd() } = {}) {
+  const resolvedDir = path.resolve(dir);
+  const nextConfigResolver = Promise.withResolvers();
+  return [
+    {
+      name: "vite-plugin-storybook-nextjs",
+      enforce: "pre",
+      async config(config, env) {
+        const phase = env.mode === "development" ? constants_js.PHASE_DEVELOPMENT_SERVER : env.mode === "test" ? constants_js.PHASE_TEST : constants_js.PHASE_PRODUCTION_BUILD;
+        nextConfigResolver.resolve(await loadConfig__default.default(phase, resolvedDir));
+        return {
+          ...!isVitestEnv && {
+            resolve: {
+              alias: {
+                react: "next/dist/compiled/react",
+                "react-dom": "next/dist/compiled/react-dom"
+              }
+            }
+          },
+          test: {
+            alias: {
+              "react/jsx-dev-runtime": require5.resolve(
+                "next/dist/compiled/react/jsx-dev-runtime.js"
+              ),
+              "react/jsx-runtime": require5.resolve(
+                "next/dist/compiled/react/jsx-runtime.js"
+              ),
+              react: require5.resolve("next/dist/compiled/react"),
+              "react-dom/test-utils": require5.resolve(
+                "next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js"
+              ),
+              "react-dom/cjs/react-dom.development.js": require5.resolve(
+                "next/dist/compiled/react-dom/cjs/react-dom.development.js"
+              ),
+              "react-dom/client": require5.resolve(
+                "next/dist/compiled/react-dom/client.js"
+              ),
+              "react-dom": require5.resolve("next/dist/compiled/react-dom")
+            }
+          }
+        };
+      },
+      configResolved(config) {
+        if (!config.test?.browser?.enabled) {
+          config.test.setupFiles = [
+            require5.resolve("./mocks/storybook.global.js"),
+            ...config.test?.setupFiles ?? []
+          ];
+        }
+      }
+    },
+    vitePluginNextFont(),
+    vitePluginNextSwc(dir, nextConfigResolver),
+    vitePluginNextEnv(dir, nextConfigResolver),
+    vitePluginNextImage(nextConfigResolver),
+    vitePluginNextMocks()
+  ];
+}
+var src_default = VitePlugin;
+
+module.exports = src_default;