@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/nextjs-vite-plugin/index.js

@@ -0,0 +1,923 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  VITEST_PLUGIN_NAME,
+  getAlias,
+  getExecutionEnvironment,
+  getNextjsMajorVersion,
+  getViteMajorVersion,
+  isVitestEnv,
+  vitePluginNextMocks
+} from "../_node-chunks/chunk-ZWBCQ4MJ.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/nextjs-vite-plugin/index.ts
+import { dirname, resolve as resolve3 } from "pathe";
+import { createRequire as createRequire3 } from "node:module";
+import tsconfigPaths from "vite-tsconfig-paths";
+
+// src/nextjs-vite-plugin/plugins/next-env/plugin.ts
+import { resolve } from "pathe";
+
+// src/nextjs-vite-plugin/utils/nextjs.ts
+import * as nextEnv from "@next/env";
+import Log from "next/dist/build/output/log.js";
+import { loadBindings, lockfilePatchPromise } from "next/dist/build/swc/index.js";
+import { findPagesDir } from "next/dist/lib/find-pages-dir.js";
+import path, { join } from "pathe";
+var nextDistPath = /(next[\\/]dist[\\/]shared[\\/]lib)|(next[\\/]dist[\\/]client)|(next[\\/]dist[\\/]pages)/, { loadEnvConfig } = nextEnv.default || nextEnv;
+async function loadEnvironmentConfig(dir, dev) {
+  return loadEnvConfig(dir, dev, Log);
+}
+async function loadSWCBindingsEagerly(nextConfig) {
+  await loadBindings(nextConfig?.experimental?.useWasmBinary), lockfilePatchPromise.cur && await lockfilePatchPromise.cur;
+}
+function shouldOutputCommonJs(filename) {
+  return filename.endsWith(".cjs") || nextDistPath.test(filename);
+}
+function findNextDirectories(dir) {
+  try {
+    return findPagesDir(dir);
+  } catch {
+    return {
+      appDir: path.join(dir, "app"),
+      pagesDir: path.join(dir, "pages")
+    };
+  }
+}
+
+// src/nextjs-vite-plugin/plugins/next-env/plugin.ts
+async function vitePluginNextEnv(rootDir, nextConfigResolver) {
+  let envConfig, isDev, resolvedDir = resolve(rootDir), getDefineEnv, isNext1540 = !1;
+  try {
+    getDefineEnv = (await import("next/dist/build/define-env.js")).getDefineEnv, isNext1540 = !0;
+  } catch {
+    getDefineEnv = // @ts-expect-error - TODO: Ignoring because types are for >= 15.4.0
+    (await import("next/dist/build/webpack/plugins/define-env-plugin.js")).getDefineEnv;
+  }
+  return {
+    name: "vite-plugin-storybook-nextjs-env",
+    enforce: "pre",
+    async config(config, env) {
+      isDev = env.mode !== "production", envConfig = (await loadEnvironmentConfig(resolvedDir, isDev)).combinedEnv;
+      let nextConfig = await nextConfigResolver.promise, finalConfig = {
+        ...Object.fromEntries(
+          Object.entries(envConfig).filter(([key]) => key.startsWith("NEXT_PUBLIC_")).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)])
+        ),
+        ...getDefineEnv({
+          isTurbopack: !1,
+          config: nextConfig,
+          isClient: !0,
+          isEdgeServer: !1,
+          isNodeServer: !1,
+          clientRouterFilters: void 0,
+          dev: isDev,
+          middlewareMatchers: void 0,
+          hasRewrites: !1,
+          distDir: nextConfig.distDir,
+          fetchCacheKeyPrefix: nextConfig?.experimental?.fetchCacheKeyPrefix,
+          ...isNext1540 ? {
+            projectPath: rootDir
+          } : {
+            isNodeOrEdgeCompilation: !1
+          }
+        })
+      };
+      return delete process.env.__NEXT_IMAGE_OPTS, delete finalConfig["process.env.__NEXT_IMAGE_OPTS"], {
+        define: finalConfig,
+        test: {
+          deps: {
+            optimizer: {
+              ssr: {
+                include: ["next"]
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/nextjs-vite-plugin/plugins/next-font/plugin.ts
+import fs from "node:fs/promises";
+import path2 from "pathe";
+
+// src/nextjs-vite-plugin/plugins/next-font/google/get-font-face-declarations.ts
+import { fetchCSSFromGoogleFonts } from "next/dist/compiled/@next/font/dist/google/fetch-css-from-google-fonts.js";
+import { getFontAxes } from "next/dist/compiled/@next/font/dist/google/get-font-axes.js";
+import { getGoogleFontsUrl } from "next/dist/compiled/@next/font/dist/google/get-google-fonts-url.js";
+import { validateGoogleFontFunctionCall } from "next/dist/compiled/@next/font/dist/google/validate-google-font-function-call.js";
+import loaderUtils from "next/dist/compiled/loader-utils3/index.js";
+var cssCache = /* @__PURE__ */ new Map();
+async function getFontFaceDeclarations(options) {
+  let { fontFamily, weights, styles, selectedVariableAxes, display, variable } = validateGoogleFontFunctionCall(options.fontFamily, options.props), fontAxes = getFontAxes(fontFamily, weights, styles, selectedVariableAxes), url = getGoogleFontsUrl(fontFamily, fontAxes, display);
+  try {
+    let hasCachedCSS = cssCache.has(url), fontFaceCSS = hasCachedCSS ? cssCache.get(url) : await fetchCSSFromGoogleFonts(url, fontFamily, !0).catch(() => null);
+    if (hasCachedCSS ? cssCache.delete(url) : cssCache.set(url, fontFaceCSS), fontFaceCSS === null)
+      throw new Error(`Failed to fetch \`${fontFamily}\` from Google Fonts with URL: \`${url}\``);
+    return {
+      id: loaderUtils.getHashDigest(url, "md5", "hex", 6),
+      fontFamily,
+      fontFaceCSS,
+      weights,
+      styles,
+      variable
+    };
+  } catch {
+    throw new Error(`Failed to fetch \`${fontFamily}\` from Google Fonts with URL: \`${url}\``);
+  }
+}
+
+// src/nextjs-vite-plugin/plugins/next-font/local/get-font-face-declarations.ts
+import { validateLocalFontFunctionCall } from "next/dist/compiled/@next/font/dist/local/validate-local-font-function-call.js";
+import loaderUtils2 from "next/dist/compiled/loader-utils3/index.js";
+import { dedent } from "ts-dedent";
+var getPlaceholderFontUrl = (refId) => `__%%import.meta.ROLLUP_FILE_URL_${refId}%%__`;
+getPlaceholderFontUrl.regexp = /__%%import\.meta\.ROLLUP_FILE_URL_(.*?)%%__/g;
+async function getFontFaceDeclarations2(options) {
+  let localFontSrc = options.props.metaSrc, {
+    weight,
+    style,
+    variable,
+    declarations = []
+  } = validateLocalFontFunctionCall("", options.props), id = `font-${loaderUtils2.getHashDigest(
+    Buffer.from(JSON.stringify(localFontSrc)),
+    "md5",
+    "hex",
+    6
+  )}`, fontDeclarations = declarations.map(({ prop, value }) => `${prop}: ${value};`).join(`
+`);
+  return {
+    id,
+    fontFamily: id,
+    fontFaceCSS: localFontSrc ? "fontReferenceId" in localFontSrc ? dedent`@font-face {
+					font-family: ${id};
+					src: url(${localFontSrc.fontReferenceId ? getPlaceholderFontUrl(localFontSrc.fontReferenceId) : `/@fs/${localFontSrc.fontPath}`});
+          ${weight ? `font-weight: ${weight};` : ""}
+          ${style ? `font-style: ${style};` : ""}
+					${fontDeclarations}
+				}` : localFontSrc.map((font) => 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("") : "",
+    weights: weight ? [weight] : [],
+    styles: style ? [style] : [],
+    variable
+  };
+}
+
+// src/nextjs-vite-plugin/utils/base64-url.ts
+function encodeBase64Url(str) {
+  return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// src/nextjs-vite-plugin/plugins/next-font/utils/get-css-meta.ts
+function getCSSMeta(options) {
+  let className = getClassName(options), style = getStylesObj(options), variableClassName = `__variable_${className}`, classNamesCSS = `
+    .${className} {
+      font-family: ${options.fontFamily};
+      ${isNextCSSPropertyValid(options.styles) ? `font-style: ${options.styles[0]};` : ""}
+      ${isNextCSSPropertyValid(options.weights) && !options.weights[0]?.includes(" ") ? `font-weight: ${options.weights[0]};` : ""}
+    }
+
+    ${options.variable ? `.${variableClassName} { ${options.variable}: '${options.fontFamily}'; }` : ""}
+  `, fontFaceCSS = `${changeFontDisplayToSwap(options.fontFaceCSS)}`;
+  return {
+    className,
+    fontFaceCSS,
+    classNamesCSS,
+    style,
+    ...options.variable ? { variableClassName } : {}
+  };
+}
+function getClassName({ styles, weights, fontFamily }) {
+  let font = fontFamily.replaceAll(" ", "-").toLowerCase(), style = isNextCSSPropertyValid(styles) ? styles[0] : null, weight = isNextCSSPropertyValid(weights) ? weights[0]?.replaceAll(" ", "-") : 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;");
+}
+
+// src/nextjs-vite-plugin/plugins/next-font/utils/set-font-declarations-in-head.ts
+import { dedent as dedent2 } from "ts-dedent";
+function setFontDeclarationsInHead({ id, fontFaceCSS, classNamesCSS }) {
+  let regex = new RegExp(getPlaceholderFontUrl.regexp), fontPaths = fontFaceCSS.matchAll(regex), fontPathsImportUrls = [];
+  if (fontPaths)
+    for (let match of fontFaceCSS.matchAll(regex))
+      fontPathsImportUrls.push({
+        id: match[1],
+        path: match[0].replaceAll(/__%%|%%__/g, "")
+      });
+  return dedent2`
+  const fontPaths = [${fontPathsImportUrls.map((fontPath) => `{id: '${fontPath.id}', path: ${fontPath.path}}`).join(", ")}];
+  if (!document.getElementById('font-face-${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/nextjs-vite-plugin/plugins/next-font/plugin.ts
+var includePattern = /next(\\|\/|\\\\).*(\\|\/|\\\\)target\.css\?.*$/, virtualFontPrefix = "\0virtual:next-font:";
+function vitePluginNextFont() {
+  let devMode = !0;
+  return {
+    name: "vite-plugin-storybook-nextjs-font",
+    enforce: "pre",
+    async config(config, env) {
+      return devMode = env.mode !== "production", {};
+    },
+    async resolveId(source, importer) {
+      let cwd = process.cwd();
+      if (!includePattern.test(source) || !importer)
+        return null;
+      let [sourceWithoutQuery, rawQuery] = source.split("?"), queryParams = JSON.parse(rawQuery), fontOptions = {
+        filename: queryParams.path ?? "",
+        fontFamily: queryParams.import ?? "",
+        props: queryParams.arguments?.[0] ?? {},
+        source: importer
+      };
+      if (fontOptions.source.endsWith("html"))
+        return null;
+      let fontFaceDeclaration, pathSep = path2.sep;
+      if (sourceWithoutQuery.endsWith(["next", "font", "google", "target.css"].join(pathSep)) && (fontFaceDeclaration = await getFontFaceDeclarations(fontOptions)), sourceWithoutQuery.endsWith(["next", "font", "local", "target.css"].join(pathSep))) {
+        let importerDirPath = path2.dirname(fontOptions.filename), emitFont = async (importerRelativeFontPath) => {
+          let fontExtension = path2.extname(importerRelativeFontPath), fontBaseName = path2.basename(importerRelativeFontPath, fontExtension), fontPath = path2.join(importerDirPath, importerRelativeFontPath);
+          if (devMode)
+            return {
+              fontPath: path2.join(cwd, fontPath),
+              fontReferenceId: void 0
+            };
+          try {
+            let fontData = await fs.readFile(fontPath);
+            return { fontReferenceId: this.emitFile({
+              name: `${fontBaseName}${fontExtension}`,
+              type: "asset",
+              source: fontData
+            }), fontPath };
+          } catch (err) {
+            console.error(`Could not read font file ${fontPath}:`, err);
+            return;
+          }
+        }, loaderOptions = {
+          ...fontOptions
+        };
+        if (loaderOptions)
+          if (typeof fontOptions.props.src == "string") {
+            let font = await emitFont(fontOptions.props.src);
+            loaderOptions.props.metaSrc = font;
+          } else
+            loaderOptions.props.metaSrc = (await Promise.all(
+              (fontOptions.props.src ?? []).map(async (fontSrc) => {
+                let font = await emitFont(fontSrc.path);
+                if (font)
+                  return {
+                    ...fontSrc,
+                    path: font
+                  };
+              })
+            )).filter((font) => font !== void 0);
+        fontFaceDeclaration = await getFontFaceDeclarations2(loaderOptions);
+      }
+      return {
+        id: `${virtualFontPrefix}${encodeBase64Url(rawQuery)}`,
+        meta: {
+          fontFaceDeclaration
+        }
+      };
+    },
+    load(id) {
+      if (!id.startsWith(virtualFontPrefix))
+        return;
+      let fontFaceDeclaration = this.getModuleInfo(id)?.meta?.fontFaceDeclaration;
+      if (typeof fontFaceDeclaration < "u") {
+        let 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/nextjs-vite-plugin/plugins/next-swc/plugin.ts
+import nextLoadJsConfig from "next/dist/build/load-jsconfig.js";
+import { transform } from "next/dist/build/swc/index.js";
+import { resolve as resolve2 } from "pathe";
+import { createFilter } from "vite";
+
+// src/nextjs-vite-plugin/utils/swc/transform.ts
+import path3 from "pathe";
+
+// src/nextjs-vite-plugin/utils/swc/options.ts
+import { getParserOptions } from "next/dist/build/swc/options.js";
+import { createRequire } from "node:module";
+
+// src/nextjs-vite-plugin/utils/swc/styles.ts
+function getStyledComponentsOptions(styledComponentsConfig, development) {
+  return styledComponentsConfig ? typeof styledComponentsConfig == "object" ? {
+    ...styledComponentsConfig,
+    displayName: styledComponentsConfig.displayName ?? !!development
+  } : {
+    displayName: !!development
+  } : null;
+}
+
+// src/nextjs-vite-plugin/utils/swc/options.ts
+var require2 = createRequire(import.meta.url), regeneratorRuntimePath = require2.resolve("next/dist/compiled/regenerator-runtime");
+function getBaseSWCOptions({
+  filename,
+  development,
+  hasReactRefresh,
+  globalWindow,
+  esm,
+  swcPlugins,
+  compiler,
+  resolvedBaseUrl,
+  jsConfig,
+  swcCacheDir
+}) {
+  let parserConfig = getParserOptions({ filename, jsConfig }), paths = jsConfig?.compilerOptions?.paths, enableDecorators = !!jsConfig?.compilerOptions?.experimentalDecorators, emitDecoratorMetadata = !!jsConfig?.compilerOptions?.emitDecoratorMetadata, useDefineForClassFields = !!jsConfig?.compilerOptions?.useDefineForClassFields, plugins = (swcPlugins ?? []).filter(Array.isArray).map(([name, options]) => [require2.resolve(name), options]);
+  return {
+    jsc: {
+      ...resolvedBaseUrl && paths ? {
+        baseUrl: resolvedBaseUrl.baseUrl,
+        paths
+      } : {},
+      externalHelpers: !1,
+      parser: parserConfig,
+      experimental: {
+        keepImportAttributes: !0,
+        emitAssertForImportAttributes: !0,
+        plugins,
+        cacheRoot: swcCacheDir
+      },
+      transform: {
+        legacyDecorator: enableDecorators,
+        decoratorMetadata: emitDecoratorMetadata,
+        useDefineForClassFields,
+        react: {
+          importSource: jsConfig?.compilerOptions?.jsxImportSource ?? "react",
+          runtime: "automatic",
+          pragmaFrag: "React.Fragment",
+          throwIfNamespace: !0,
+          development: !!development,
+          useBuiltins: !0,
+          refresh: !!hasReactRefresh
+        },
+        optimizer: {
+          simplify: !1,
+          // 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: !0,
+    removeConsole: compiler?.removeConsole,
+    reactRemoveProperties: !1,
+    relay: compiler?.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
+    styledComponents: getStyledComponentsOptions(compiler?.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/nextjs-vite-plugin/utils/swc/transform.ts
+var getVitestSWCTransformConfig = async ({
+  filename,
+  inputSourceMap,
+  isServerEnvironment,
+  loadedJSConfig,
+  nextDirectories,
+  nextConfig,
+  rootDir,
+  isDev,
+  isEsmProject
+}) => {
+  let { compilerOptions, ...restJSConfig } = loadedJSConfig.jsConfig ?? {}, { paths, ...restCompilerOptions } = compilerOptions ?? {}, baseOptions = getBaseSWCOptions({
+    filename,
+    development: isDev,
+    hasReactRefresh: !1,
+    globalWindow: !isServerEnvironment,
+    jsConfig: {
+      ...restJSConfig,
+      compilerOptions: {
+        ...restCompilerOptions
+      }
+    },
+    resolvedBaseUrl: loadedJSConfig.resolvedBaseUrl,
+    swcPlugins: nextConfig.experimental.swcPlugins,
+    compiler: nextConfig?.compiler,
+    esm: isEsmProject,
+    swcCacheDir: path3.join(rootDir, nextConfig.distDir ?? ".next", "cache", "swc")
+  }), useCjsModules = shouldOutputCommonJs(filename), isPageFile = nextDirectories.pagesDir ? filename.startsWith(nextDirectories.pagesDir) : !1;
+  return {
+    ...baseOptions,
+    fontLoaders: {
+      fontLoaders: ["next/font/local", "next/font/google"],
+      relativeFilePathFromRoot: path3.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: await getSupportedBrowsers(rootDir, isDev),
+        bugfixes: !0
+      }
+    },
+    module: {
+      type: isEsmProject && !useCjsModules ? "es6" : "commonjs"
+    },
+    disableNextSsg: !isPageFile,
+    isPageFile,
+    pagesDir: nextDirectories.pagesDir,
+    appDir: nextDirectories.appDir,
+    isDevelopment: isDev,
+    isServerCompiler: isServerEnvironment,
+    inputSourceMap: inputSourceMap && typeof inputSourceMap == "object" ? JSON.stringify(inputSourceMap) : void 0,
+    sourceFileName: filename,
+    filename
+  };
+};
+async function getSupportedBrowsers(projectRoot, isDevelopment) {
+  try {
+    return (await import(
+      // @ts-expect-error - Correct import since Next.js v16.2
+      "next/dist/build/get-supported-browsers.js"
+    )).getSupportedBrowsers(projectRoot, isDevelopment);
+  } catch {
+    return (await import("next/dist/build/utils.js")).getSupportedBrowsers(
+      projectRoot,
+      isDevelopment
+    );
+  }
+}
+
+// src/nextjs-vite-plugin/utils/typescript.ts
+var isDefined = (value) => value !== void 0;
+
+// src/nextjs-vite-plugin/plugins/next-swc/plugin.ts
+var excluded = /[\\/]((cache[\\/][^\\/]+\.zip[\\/])|virtual:)[\\/]/, included = /\.((c|m)?(j|t)sx?)$/, loadJsConfig = (
+  // biome-ignore lint/suspicious/noExplicitAny: CJS support
+  nextLoadJsConfig.default || nextLoadJsConfig
+);
+function vitePluginNextSwc(rootDir, nextConfigResolver) {
+  let loadedJSConfig, nextDirectories, isServerEnvironment, isDev, isEsmProject, filter = createFilter(included, excluded), resolvedDir = resolve2(rootDir);
+  return {
+    name: "vite-plugin-storybook-nextjs-swc",
+    enforce: "pre",
+    async config(config, env) {
+      let nextConfig = await nextConfigResolver.promise;
+      nextDirectories = findNextDirectories(resolvedDir), loadedJSConfig = await loadJsConfig(resolvedDir, nextConfig), isDev = env.mode !== "production", isEsmProject = !0, await loadSWCBindingsEagerly(nextConfig);
+      let serverWatchIgnored = config.server?.watch?.ignored, isServerWatchIgnoredArray = Array.isArray(serverWatchIgnored);
+      return isServerEnvironment = !1, isVitestEnv && (isServerEnvironment = config.test?.environment === "node" || config.test?.environment === "edge-runtime" || config.test?.browser?.enabled !== !0), {
+        // 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 (id.includes("/node_modules/") || !filter(id))
+        return;
+      let inputSourceMap = this.getCombinedSourcemap();
+      return await transform(
+        code,
+        await getVitestSWCTransformConfig({
+          filename: id,
+          inputSourceMap,
+          isServerEnvironment,
+          loadedJSConfig,
+          nextConfig: await nextConfigResolver.promise,
+          nextDirectories,
+          rootDir,
+          isDev,
+          isEsmProject
+        })
+      );
+    }
+  };
+}
+
+// src/nextjs-vite-plugin/polyfills/promise-with-resolvers.ts
+typeof Promise.withResolvers > "u" && (Promise.withResolvers = () => {
+  let resolve4, reject;
+  return { promise: new Promise((res, rej) => {
+    resolve4 = res, reject = rej;
+  }), resolve: resolve4, reject };
+});
+
+// src/nextjs-vite-plugin/index.ts
+import nextLoadJsConfig2 from "next/dist/build/load-jsconfig.js";
+import {
+  PHASE_DEVELOPMENT_SERVER,
+  PHASE_PRODUCTION_BUILD,
+  PHASE_TEST
+} from "next/dist/shared/lib/constants.js";
+
+// src/nextjs-vite-plugin/plugins/next-dynamic/plugin.ts
+import MagicString from "magic-string";
+var vitePluginNextDynamic = () => ({
+  name: "vite-plugin-storybook-nextjs-dynamic",
+  transform(code, id) {
+    let dynamicImportRegex = /dynamic\(\s*async\s*\(\s*\)\s*=>\s*\{\s*typeof\s*require\.resolveWeak\s*!==\s*"undefined"\s*&&\s*require\.resolveWeak\(([^)]+)\);\s*\}/g;
+    if (dynamicImportRegex.test(code)) {
+      let s = new MagicString(code);
+      dynamicImportRegex.lastIndex = 0;
+      let match = dynamicImportRegex.exec(code);
+      for (; match !== null; ) {
+        let [fullMatch, importPath] = match, newImport = `dynamic(() => import(${importPath})`;
+        s.overwrite(match.index, match.index + fullMatch.length, newImport), match = dynamicImportRegex.exec(code);
+      }
+      return {
+        code: s.toString(),
+        map: s.generateMap({ hires: !0 })
+      };
+    }
+    return null;
+  }
+});
+
+// src/nextjs-vite-plugin/plugins/next-image/plugin.ts
+import { createHash } from "node:crypto";
+import fs2 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { createFilter as createFilter2 } from "@rollup/pluginutils";
+import path4 from "pathe";
+import probeSync from "probe-image-size/sync.js";
+import { dedent as dedent3 } from "ts-dedent";
+var warnedMessages = /* @__PURE__ */ new Set(), warnOnce = (message) => {
+  warnedMessages.has(message) || (console.warn(`[@aussieljk/forkbook/internal/nextjs-vite-plugin] ${message}`), warnedMessages.add(message));
+}, includePattern2 = /\.(png|jpg|jpeg|gif|webp|avif|ico|bmp|svg)$/, excludeImporterPattern = /\.(css|scss|sass)$/, virtualImagePrefix = "\0virtual:next-image:";
+var virtualNextImage = "virtual:next/image", virtualNextLegacyImage = "virtual:next/legacy/image", SHORT_HASH_LEN = 8, require3 = createRequire2(import.meta.url);
+function vitePluginNextImage(nextConfigResolver, options = {}) {
+  let isBrowser = !isVitestEnv, hasVitePluginSvgr = !1, postfixRE = /[?#].*$/s, filter = createFilter2(
+    options.includeFiles ?? [
+      "**/*.{png,jpg,jpeg,gif,webp,avif,ico,bmp,svg}",
+      "**/*.{png,jpg,jpeg,gif,webp,avif,ico,bmp,svg}?*",
+      "**/*.{png,jpg,jpeg,gif,webp,avif,ico,bmp,svg}#*"
+    ],
+    options.excludeFiles
+  ), imagePathByHash = /* @__PURE__ */ new Map();
+  function registerImagePath(imagePath) {
+    let full = createHash("sha256").update(imagePath).digest("hex"), short = full.slice(0, SHORT_HASH_LEN), existing = imagePathByHash.get(short);
+    return existing === imagePath ? short : existing === void 0 ? (imagePathByHash.set(short, imagePath), short) : (imagePathByHash.set(full, imagePath), full);
+  }
+  return {
+    name: "vite-plugin-storybook-nextjs-image",
+    enforce: "pre",
+    async configResolved(config) {
+      hasVitePluginSvgr = !!config.plugins?.some(
+        (plugin) => plugin && typeof plugin == "object" && "name" in plugin && (plugin.name === "vite-plugin-svgr" || plugin.name.includes("svgr"))
+      );
+    },
+    async config(config, env) {
+      return config.test?.browser?.enabled === !0 && (isBrowser = !0), {
+        resolve: {
+          alias: getAlias(isBrowser ? "browser" : "node")
+        }
+      };
+    },
+    async resolveId(id, importer) {
+      let [source, queryA] = id.split("?");
+      if (queryA === "ignore")
+        return null;
+      let isSvg = /\.svg$/.test(source);
+      if (isSvg && hasVitePluginSvgr && queryA === "react")
+        return null;
+      if (isSvg && hasVitePluginSvgr && !options.includeFiles && !options.excludeFiles && queryA !== void 0 && warnOnce(
+        dedent3`Detected vite-plugin-svgr but you are not passing image include or exclude patterns to the nextjs-vite plugin. This may cause a conflict between the two plugins and issues with SVG files.
+          
+          For more info and recommended configuration, see: https://github.com/storybookjs/storybook/blob/next/code/lib/vite-plugin-storybook-nextjs/README.md#faq-includingexcluding-images`
+      ), includePattern2.test(source) && !excludeImporterPattern.test(importer ?? "") && !importer?.startsWith(virtualImagePrefix)) {
+        let isAbsolute = path4.isAbsolute(source), importerPath = importer?.split("?")[0], imagePath = source;
+        if (importerPath && !isAbsolute)
+          if (source.startsWith("."))
+            imagePath = path4.join(path4.dirname(importerPath), source);
+          else {
+            let resolvedByVite = await this.resolve(source, importer, {
+              skipSelf: !0
+            });
+            if (resolvedByVite?.id)
+              imagePath = resolvedByVite.id.split("?")[0];
+            else
+              try {
+                imagePath = require3.resolve(source, {
+                  paths: [path4.dirname(importerPath)]
+                });
+              } catch {
+                return null;
+              }
+          }
+        let pathForFilter = imagePath.replace(postfixRE, "");
+        return filter(pathForFilter) ? `${virtualImagePrefix}${registerImagePath(imagePath)}` : null;
+      }
+      return id === "next/image" && importer !== virtualNextImage ? virtualNextImage : id === "next/legacy/image" && importer !== virtualNextLegacyImage ? virtualNextLegacyImage : null;
+    },
+    async load(id) {
+      let aliasEnv = isBrowser ? "browser" : "node";
+      if (virtualNextImage === id)
+        return (await fs2.promises.readFile(
+          require3.resolve(`${VITEST_PLUGIN_NAME}/${aliasEnv}/mocks/image`)
+        )).toString("utf-8");
+      if (virtualNextLegacyImage === id)
+        return (await fs2.promises.readFile(
+          require3.resolve(`${VITEST_PLUGIN_NAME}/${aliasEnv}/mocks/legacy-image`)
+        )).toString("utf-8");
+      if (id.startsWith(virtualImagePrefix)) {
+        let imagePath = imagePathByHash.get(id.slice(virtualImagePrefix.length));
+        if (imagePath === void 0)
+          return null;
+        let nextConfig = await nextConfigResolver.promise;
+        try {
+          if (nextConfig.images?.disableStaticImages)
+            return dedent3`
+						import image from "${imagePath}?ignore";
+						export default image;
+					`;
+          let imageData = await fs2.promises.readFile(imagePath), size = probeSync(imageData);
+          if (!size)
+            throw new Error("Unsupported or corrupt image file");
+          let { width, height } = size;
+          return dedent3`
+						import src from "${imagePath}?ignore";
+						export default {
+							src,
+							height: ${height},
+							width: ${width},
+							blurDataURL: src
+						};
+					`;
+        } catch (err) {
+          console.error(`Could not read image file ${imagePath}:`, err);
+          return;
+        }
+      }
+      return null;
+    }
+  };
+}
+
+// src/nextjs-vite-plugin/utils/next-config.ts
+import { normalizeConfig } from "next/dist/server/config-shared.js";
+import nextServerConfig from "next/dist/server/config.js";
+var loadConfig = (
+  // biome-ignore lint/suspicious/noExplicitAny: CJS support
+  nextServerConfig.default || nextServerConfig
+), TURBOPACK_RUST_REACT_COMPILER_ERROR = "`experimental.turbopackRustReactCompiler` is only supported with Turbopack.";
+async function loadNextConfig(phase, dir) {
+  let nextConfig;
+  try {
+    nextConfig = await loadConfig(phase, dir);
+  } catch (error) {
+    if (!isTurbopackRustReactCompilerError(error))
+      throw error;
+    return loadNormalizedNextConfig(phase, dir);
+  }
+  return isResolvedNextConfig(nextConfig) ? nextConfig : loadNormalizedNextConfig(phase, dir, nextConfig);
+}
+async function loadNormalizedNextConfig(phase, dir, cachedRawConfigModule) {
+  let rawConfigModule = cachedRawConfigModule ?? await loadConfig(phase, dir, { rawConfig: !0 }), rawConfig = interopDefault(rawConfigModule), normalizedConfig = await normalizeConfig(phase, rawConfig), { turbopackRustReactCompiler: _turbopackRustReactCompiler, ...experimental } = normalizedConfig.experimental ?? {};
+  return loadConfig(phase, dir, {
+    customConfig: {
+      ...normalizedConfig,
+      experimental
+    }
+  });
+}
+function isResolvedNextConfig(config) {
+  return typeof config.configFileName == "string";
+}
+function isTurbopackRustReactCompilerError(error) {
+  return error instanceof Error && error.message.startsWith(TURBOPACK_RUST_REACT_COMPILER_ERROR);
+}
+function interopDefault(module) {
+  return typeof module == "object" && module !== null && "default" in module ? module.default ?? module : module;
+}
+
+// src/nextjs-vite-plugin/index.ts
+var require4 = createRequire3(import.meta.url), compiledReactDir = dirname(require4.resolve("next/dist/compiled/react")), compiledReactDomDir = dirname(require4.resolve("next/dist/compiled/react-dom")), loadJsConfig2 = (
+  // biome-ignore lint/suspicious/noExplicitAny: CJS support
+  nextLoadJsConfig2.default || nextLoadJsConfig2
+);
+function VitePlugin({ dir = process.cwd(), image } = {}) {
+  let resolvedDir = resolve3(dir), isVite8orNewer = getViteMajorVersion() >= 8, nextConfigResolver = Promise.withResolvers(), nodeEnv = process.env.NODE_ENV;
+  return loadNextConfig(nodeEnv === "development" ? PHASE_DEVELOPMENT_SERVER : nodeEnv === "test" ? PHASE_TEST : PHASE_PRODUCTION_BUILD, resolvedDir).then(nextConfigResolver.resolve, nextConfigResolver.reject), [
+    isVite8orNewer ? null : nextConfigResolver.promise.then(async (nextConfig) => {
+      let loadedJSConfig = await loadJsConfig2(resolvedDir, nextConfig), { enforce, ...tsconfigPathConfig } = tsconfigPaths({
+        root: resolvedDir,
+        ...loadedJSConfig.jsConfigPath ? { projects: [loadedJSConfig.jsConfigPath] } : {}
+      });
+      return {
+        ...tsconfigPathConfig
+      };
+    }),
+    {
+      name: "@aussieljk/forkbook/internal/nextjs-vite-plugin",
+      enforce: "pre",
+      async config(config) {
+        let isNext16orNewer = getNextjsMajorVersion() >= 16, nextConfig = await nextConfigResolver.promise, executionEnvironment = getExecutionEnvironment(config), resolveConfig = {
+          ...isVite8orNewer ? { tsconfigPaths: !0 } : {},
+          ...!isVitestEnv && {
+            alias: [
+              {
+                find: /^react$/,
+                replacement: require4.resolve("next/dist/compiled/react")
+              },
+              {
+                find: /^react\/jsx-runtime$/,
+                replacement: require4.resolve("next/dist/compiled/react/jsx-runtime")
+              },
+              {
+                find: /^react\/jsx-dev-runtime$/,
+                replacement: require4.resolve("next/dist/compiled/react/jsx-dev-runtime")
+              },
+              {
+                find: /^react-dom$/,
+                replacement: require4.resolve("next/dist/compiled/react-dom")
+              },
+              {
+                find: /^react-dom\/server$/,
+                replacement: require4.resolve("next/dist/compiled/react-dom/server.browser.js")
+              },
+              {
+                find: /^react-dom\/test-utils$/,
+                replacement: require4.resolve("next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js")
+              },
+              {
+                find: /^react-dom\/client$/,
+                replacement: require4.resolve("next/dist/compiled/react-dom/client.js")
+              },
+              {
+                find: /^react-dom\/cjs\/react-dom\.development\.js$/,
+                replacement: require4.resolve("next/dist/compiled/react-dom/cjs/react-dom.development.js")
+              }
+            ]
+          }
+        };
+        return {
+          ...Object.keys(resolveConfig).length > 0 ? { resolve: resolveConfig } : {},
+          optimizeDeps: {
+            include: [
+              "next/dist/shared/lib/app-router-context.shared-runtime",
+              "next/dist/shared/lib/head-manager-context.shared-runtime",
+              "next/dist/shared/lib/hooks-client-context.shared-runtime",
+              "next/dist/shared/lib/router-context.shared-runtime",
+              "next/dist/client/components/redirect-boundary",
+              "next/dist/client/head-manager",
+              "next/dist/client/components/is-next-router-error",
+              "next/dist/shared/lib/segment",
+              "next/dist/shared/lib/app-router-context.shared-runtime.js",
+              "next/dist/shared/lib/head-manager-context.shared-runtime.js",
+              "next/dist/shared/lib/hooks-client-context.shared-runtime.js",
+              "next/dist/shared/lib/router-context.shared-runtime.js",
+              "next/dist/client/components/redirect-boundary.js",
+              "next/dist/client/head-manager.js",
+              "next/dist/client/components/is-next-router-error.js",
+              "next/dist/shared/lib/segment.js",
+              "styled-jsx",
+              "styled-jsx/style",
+              "sb-original/image-context",
+              "sb-original/default-loader",
+              "next/dist/compiled/react",
+              "next/image",
+              "next/legacy/image",
+              "react/jsx-dev-runtime",
+              // Required for pnpm setups, since styled-jsx is a transitive dependency of Next.js and not directly listed.
+              // Refer to this pnpm issue for more details:
+              // https://github.com/vitejs/vite/issues/16293
+              "next > styled-jsx/style",
+              ...isNext16orNewer ? [] : ["next/config"],
+              // Next.js 16 ships internal re-export chains that Vite's esbuild
+              // pre-bundler fails to resolve in dev mode, causing missing exports
+              // like ServerInsertedHTMLContext and RedirectStatusCode. Forcing
+              // these modules to be pre-bundled fixes the resolution.
+              // See: https://github.com/storybookjs/storybook/issues/34688
+              ...isNext16orNewer ? ["next/navigation", "next/dist/client/components/redirect-error"] : []
+            ]
+          },
+          test: {
+            alias: {
+              "next/dist/compiled/react": compiledReactDir,
+              "next/dist/compiled/react-dom": compiledReactDomDir,
+              "react/jsx-dev-runtime": require4.resolve("next/dist/compiled/react/jsx-dev-runtime.js"),
+              "react/jsx-runtime": require4.resolve("next/dist/compiled/react/jsx-runtime.js"),
+              react: require4.resolve("next/dist/compiled/react"),
+              "react-dom/server": require4.resolve(
+                executionEnvironment === "node" ? "next/dist/compiled/react-dom/server.js" : "next/dist/compiled/react-dom/server.browser.js"
+              ),
+              "react-dom/test-utils": require4.resolve("next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js"),
+              "react-dom/cjs/react-dom.development.js": require4.resolve("next/dist/compiled/react-dom/cjs/react-dom.development.js"),
+              "react-dom/client": require4.resolve("next/dist/compiled/react-dom/client.js"),
+              "react-dom": require4.resolve("next/dist/compiled/react-dom")
+            }
+          }
+        };
+      },
+      configResolved(config) {
+        isVitestEnv && !config.test?.browser?.enabled && (config.test.setupFiles = [
+          require4.resolve("./mocks/storybook.global.js"),
+          ...config.test?.setupFiles ?? []
+        ]);
+      }
+    },
+    vitePluginNextFont(),
+    vitePluginNextSwc(dir, nextConfigResolver),
+    vitePluginNextEnv(dir, nextConfigResolver),
+    vitePluginNextImage(nextConfigResolver, image),
+    vitePluginNextMocks(),
+    vitePluginNextDynamic()
+  ];
+}
+var nextjs_vite_plugin_default = VitePlugin;
+export {
+  nextjs_vite_plugin_default as default
+};