@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/nextjs-vite/preset.js

@@ -0,0 +1,648 @@
+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 {
+  resolvePackageDir
+} from "../_node-chunks/chunk-F3ZFKBHY.js";
+import "../_node-chunks/chunk-TNJIXE37.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "../_node-chunks/chunk-CXRU72ET.js";
+
+// ../../node_modules/lilconfig/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/lilconfig/src/index.js"(exports, module) {
+    var path = __require("path"), fs = __require("fs"), os = __require("os"), url = __require("url"), fsReadFileAsync = fs.promises.readFile;
+    function getDefaultSearchPlaces(name, sync) {
+      return [
+        "package.json",
+        `.${name}rc.json`,
+        `.${name}rc.js`,
+        `.${name}rc.cjs`,
+        ...sync ? [] : [`.${name}rc.mjs`],
+        `.config/${name}rc`,
+        `.config/${name}rc.json`,
+        `.config/${name}rc.js`,
+        `.config/${name}rc.cjs`,
+        ...sync ? [] : [`.config/${name}rc.mjs`],
+        `${name}.config.js`,
+        `${name}.config.cjs`,
+        ...sync ? [] : [`${name}.config.mjs`]
+      ];
+    }
+    function parentDir(p) {
+      return path.dirname(p) || path.sep;
+    }
+    var jsonLoader = (_, content) => JSON.parse(content), requireFunc = typeof __webpack_require__ == "function" ? __non_webpack_require__ : __require, defaultLoadersSync = Object.freeze({
+      ".js": requireFunc,
+      ".json": requireFunc,
+      ".cjs": requireFunc,
+      noExt: jsonLoader
+    });
+    module.exports.defaultLoadersSync = defaultLoadersSync;
+    var dynamicImport = async (id) => {
+      try {
+        return (await import(url.pathToFileURL(id).href)).default;
+      } catch (e) {
+        try {
+          return requireFunc(id);
+        } catch (requireE) {
+          throw requireE.code === "ERR_REQUIRE_ESM" || requireE instanceof SyntaxError && requireE.toString().includes("Cannot use import statement outside a module") ? e : requireE;
+        }
+      }
+    }, defaultLoaders = Object.freeze({
+      ".js": dynamicImport,
+      ".mjs": dynamicImport,
+      ".cjs": dynamicImport,
+      ".json": jsonLoader,
+      noExt: jsonLoader
+    });
+    module.exports.defaultLoaders = defaultLoaders;
+    function getOptions(name, options, sync) {
+      let conf = {
+        stopDir: os.homedir(),
+        searchPlaces: getDefaultSearchPlaces(name, sync),
+        ignoreEmptySearchPlaces: !0,
+        cache: !0,
+        transform: (x) => x,
+        packageProp: [name],
+        ...options,
+        loaders: {
+          ...sync ? defaultLoadersSync : defaultLoaders,
+          ...options.loaders
+        }
+      };
+      return conf.searchPlaces.forEach((place) => {
+        let key = path.extname(place) || "noExt", loader2 = conf.loaders[key];
+        if (!loader2)
+          throw new Error(`Missing loader for extension "${place}"`);
+        if (typeof loader2 != "function")
+          throw new Error(
+            `Loader for extension "${place}" is not a function: Received ${typeof loader2}.`
+          );
+      }), conf;
+    }
+    function getPackageProp(props, obj) {
+      return typeof props == "string" && props in obj ? obj[props] : (Array.isArray(props) ? props : props.split(".")).reduce(
+        (acc, prop) => acc === void 0 ? acc : acc[prop],
+        obj
+      ) || null;
+    }
+    function validateFilePath(filepath) {
+      if (!filepath) throw new Error("load must pass a non-empty string");
+    }
+    function validateLoader(loader2, ext) {
+      if (!loader2) throw new Error(`No loader specified for extension "${ext}"`);
+      if (typeof loader2 != "function") throw new Error("loader is not a function");
+    }
+    var makeEmplace = (enableCache) => (c, filepath, res) => (enableCache && c.set(filepath, res), res);
+    module.exports.lilconfig = function(name, options) {
+      let {
+        ignoreEmptySearchPlaces,
+        loaders,
+        packageProp,
+        searchPlaces,
+        stopDir,
+        transform,
+        cache
+      } = getOptions(name, options ?? {}, !1), searchCache = /* @__PURE__ */ new Map(), loadCache = /* @__PURE__ */ new Map(), emplace = makeEmplace(cache);
+      return {
+        async search(searchFrom = process.cwd()) {
+          let result = {
+            config: null,
+            filepath: ""
+          }, visited = /* @__PURE__ */ new Set(), dir = searchFrom;
+          dirLoop: for (; ; ) {
+            if (cache) {
+              let r = searchCache.get(dir);
+              if (r !== void 0) {
+                for (let p of visited) searchCache.set(p, r);
+                return r;
+              }
+              visited.add(dir);
+            }
+            for (let searchPlace of searchPlaces) {
+              let filepath = path.join(dir, searchPlace);
+              try {
+                await fs.promises.access(filepath);
+              } catch {
+                continue;
+              }
+              let content = String(await fsReadFileAsync(filepath)), loaderKey = path.extname(searchPlace) || "noExt", loader2 = loaders[loaderKey];
+              if (searchPlace === "package.json") {
+                let pkg = await loader2(filepath, content), maybeConfig = getPackageProp(packageProp, pkg);
+                if (maybeConfig != null) {
+                  result.config = maybeConfig, result.filepath = filepath;
+                  break dirLoop;
+                }
+                continue;
+              }
+              let isEmpty = content.trim() === "";
+              if (!(isEmpty && ignoreEmptySearchPlaces)) {
+                isEmpty ? (result.isEmpty = !0, result.config = void 0) : (validateLoader(loader2, loaderKey), result.config = await loader2(filepath, content)), result.filepath = filepath;
+                break dirLoop;
+              }
+            }
+            if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+            dir = parentDir(dir);
+          }
+          let transformed = (
+            // not found
+            result.filepath === "" && result.config === null ? transform(null) : transform(result)
+          );
+          if (cache)
+            for (let p of visited) searchCache.set(p, transformed);
+          return transformed;
+        },
+        async load(filepath) {
+          validateFilePath(filepath);
+          let absPath = path.resolve(process.cwd(), filepath);
+          if (cache && loadCache.has(absPath))
+            return loadCache.get(absPath);
+          let { base, ext } = path.parse(absPath), loaderKey = ext || "noExt", loader2 = loaders[loaderKey];
+          validateLoader(loader2, loaderKey);
+          let content = String(await fsReadFileAsync(absPath));
+          if (base === "package.json") {
+            let pkg = await loader2(absPath, content);
+            return emplace(
+              loadCache,
+              absPath,
+              transform({
+                config: getPackageProp(packageProp, pkg),
+                filepath: absPath
+              })
+            );
+          }
+          let result = {
+            config: null,
+            filepath: absPath
+          }, isEmpty = content.trim() === "";
+          return isEmpty && ignoreEmptySearchPlaces ? emplace(
+            loadCache,
+            absPath,
+            transform({
+              config: void 0,
+              filepath: absPath,
+              isEmpty: !0
+            })
+          ) : (result.config = isEmpty ? void 0 : await loader2(absPath, content), emplace(
+            loadCache,
+            absPath,
+            transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result)
+          ));
+        },
+        clearLoadCache() {
+          cache && loadCache.clear();
+        },
+        clearSearchCache() {
+          cache && searchCache.clear();
+        },
+        clearCaches() {
+          cache && (loadCache.clear(), searchCache.clear());
+        }
+      };
+    };
+    module.exports.lilconfigSync = function(name, options) {
+      let {
+        ignoreEmptySearchPlaces,
+        loaders,
+        packageProp,
+        searchPlaces,
+        stopDir,
+        transform,
+        cache
+      } = getOptions(name, options ?? {}, !0), searchCache = /* @__PURE__ */ new Map(), loadCache = /* @__PURE__ */ new Map(), emplace = makeEmplace(cache);
+      return {
+        search(searchFrom = process.cwd()) {
+          let result = {
+            config: null,
+            filepath: ""
+          }, visited = /* @__PURE__ */ new Set(), dir = searchFrom;
+          dirLoop: for (; ; ) {
+            if (cache) {
+              let r = searchCache.get(dir);
+              if (r !== void 0) {
+                for (let p of visited) searchCache.set(p, r);
+                return r;
+              }
+              visited.add(dir);
+            }
+            for (let searchPlace of searchPlaces) {
+              let filepath = path.join(dir, searchPlace);
+              try {
+                fs.accessSync(filepath);
+              } catch {
+                continue;
+              }
+              let loaderKey = path.extname(searchPlace) || "noExt", loader2 = loaders[loaderKey], content = String(fs.readFileSync(filepath));
+              if (searchPlace === "package.json") {
+                let pkg = loader2(filepath, content), maybeConfig = getPackageProp(packageProp, pkg);
+                if (maybeConfig != null) {
+                  result.config = maybeConfig, result.filepath = filepath;
+                  break dirLoop;
+                }
+                continue;
+              }
+              let isEmpty = content.trim() === "";
+              if (!(isEmpty && ignoreEmptySearchPlaces)) {
+                isEmpty ? (result.isEmpty = !0, result.config = void 0) : (validateLoader(loader2, loaderKey), result.config = loader2(filepath, content)), result.filepath = filepath;
+                break dirLoop;
+              }
+            }
+            if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+            dir = parentDir(dir);
+          }
+          let transformed = (
+            // not found
+            result.filepath === "" && result.config === null ? transform(null) : transform(result)
+          );
+          if (cache)
+            for (let p of visited) searchCache.set(p, transformed);
+          return transformed;
+        },
+        load(filepath) {
+          validateFilePath(filepath);
+          let absPath = path.resolve(process.cwd(), filepath);
+          if (cache && loadCache.has(absPath))
+            return loadCache.get(absPath);
+          let { base, ext } = path.parse(absPath), loaderKey = ext || "noExt", loader2 = loaders[loaderKey];
+          validateLoader(loader2, loaderKey);
+          let content = String(fs.readFileSync(absPath));
+          if (base === "package.json") {
+            let pkg = loader2(absPath, content);
+            return transform({
+              config: getPackageProp(packageProp, pkg),
+              filepath: absPath
+            });
+          }
+          let result = {
+            config: null,
+            filepath: absPath
+          }, isEmpty = content.trim() === "";
+          return isEmpty && ignoreEmptySearchPlaces ? emplace(
+            loadCache,
+            absPath,
+            transform({
+              filepath: absPath,
+              config: void 0,
+              isEmpty: !0
+            })
+          ) : (result.config = isEmpty ? void 0 : loader2(absPath, content), emplace(
+            loadCache,
+            absPath,
+            transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result)
+          ));
+        },
+        clearLoadCache() {
+          cache && loadCache.clear();
+        },
+        clearSearchCache() {
+          cache && searchCache.clear();
+        },
+        clearCaches() {
+          cache && (loadCache.clear(), searchCache.clear());
+        }
+      };
+    };
+  }
+});
+
+// ../../node_modules/postcss-load-config/src/req.js
+var require_req = __commonJS({
+  "../../node_modules/postcss-load-config/src/req.js"(exports, module) {
+    var { createRequire: createRequire2 } = __require("node:module"), { pathToFileURL } = __require("node:url"), TS_EXT_RE = /\.[mc]?ts$/, tsx, jiti, importError = [];
+    async function req(name, rootFile = __filename) {
+      let url = createRequire2(rootFile).resolve(name);
+      try {
+        return (await import(`${pathToFileURL(url)}?t=${Date.now()}`)).default;
+      } catch (err) {
+        if (!TS_EXT_RE.test(url))
+          throw err;
+      }
+      if (tsx === void 0)
+        try {
+          tsx = await import("tsx/cjs/api");
+        } catch (error) {
+          importError.push(error);
+        }
+      if (tsx) {
+        let loaded = tsx.require(name, rootFile);
+        return loaded && "__esModule" in loaded ? loaded.default : loaded;
+      }
+      if (jiti === void 0)
+        try {
+          jiti = (await import("../_node-chunks/jiti-NFX6UU74.js")).default;
+        } catch (error) {
+          importError.push(error);
+        }
+      if (jiti)
+        return jiti(rootFile, { interopDefault: !0 })(name);
+      throw new Error(
+        `'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed
+Error: ${importError.map((error) => error.message).join(`
+`)}`
+      );
+    }
+    module.exports = req;
+  }
+});
+
+// ../../node_modules/postcss-load-config/src/options.js
+var require_options = __commonJS({
+  "../../node_modules/postcss-load-config/src/options.js"(exports, module) {
+    var req = require_req();
+    async function options(config2, file) {
+      if (config2.parser && typeof config2.parser == "string")
+        try {
+          config2.parser = await req(config2.parser, file);
+        } catch (err) {
+          throw new Error(
+            `Loading PostCSS Parser failed: ${err.message}
+
+(@${file})`
+          );
+        }
+      if (config2.syntax && typeof config2.syntax == "string")
+        try {
+          config2.syntax = await req(config2.syntax, file);
+        } catch (err) {
+          throw new Error(
+            `Loading PostCSS Syntax failed: ${err.message}
+
+(@${file})`
+          );
+        }
+      if (config2.stringifier && typeof config2.stringifier == "string")
+        try {
+          config2.stringifier = await req(config2.stringifier, file);
+        } catch (err) {
+          throw new Error(
+            `Loading PostCSS Stringifier failed: ${err.message}
+
+(@${file})`
+          );
+        }
+      return config2;
+    }
+    module.exports = options;
+  }
+});
+
+// ../../node_modules/postcss-load-config/src/plugins.js
+var require_plugins = __commonJS({
+  "../../node_modules/postcss-load-config/src/plugins.js"(exports, module) {
+    var req = require_req();
+    async function load(plugin, options, file) {
+      try {
+        return options == null || Object.keys(options).length === 0 ? await req(plugin, file) : (await req(plugin, file))(options);
+      } catch (err) {
+        throw new Error(
+          `Loading PostCSS Plugin failed: ${err.message}
+
+(@${file})`
+        );
+      }
+    }
+    async function plugins(config2, file) {
+      let list = [];
+      return Array.isArray(config2.plugins) ? list = config2.plugins.filter(Boolean) : (list = Object.entries(config2.plugins).filter(([, options]) => options !== !1).map(([plugin, options]) => load(plugin, options, file)), list = await Promise.all(list)), list.length && list.length > 0 && list.forEach((plugin, i) => {
+        if (plugin.default && (plugin = plugin.default), plugin.postcss === !0 ? plugin = plugin() : plugin.postcss && (plugin = plugin.postcss), !(typeof plugin == "object" && Array.isArray(plugin.plugins) || typeof plugin == "object" && plugin.postcssPlugin || typeof plugin == "function"))
+          throw new TypeError(
+            `Invalid PostCSS Plugin found at: plugins[${i}]
+
+(@${file})`
+          );
+      }), list;
+    }
+    module.exports = plugins;
+  }
+});
+
+// ../../node_modules/postcss-load-config/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/postcss-load-config/src/index.js"(exports, module) {
+    var { resolve } = __require("node:path"), config2 = require_src(), loadOptions = require_options(), loadPlugins = require_plugins(), req = require_req(), interopRequireDefault = (obj) => obj && obj.__esModule ? obj : { default: obj };
+    async function processResult(ctx, result) {
+      let file = result.filepath || "", projectConfig = interopRequireDefault(result.config).default || {};
+      typeof projectConfig == "function" ? projectConfig = projectConfig(ctx) : projectConfig = Object.assign({}, projectConfig, ctx), projectConfig.plugins || (projectConfig.plugins = []);
+      let res = {
+        file,
+        options: await loadOptions(projectConfig, file),
+        plugins: await loadPlugins(projectConfig, file)
+      };
+      return delete projectConfig.plugins, res;
+    }
+    function createContext(ctx) {
+      return ctx = Object.assign(
+        {
+          cwd: process.cwd(),
+          env: process.env.NODE_ENV
+        },
+        ctx
+      ), ctx.env || (process.env.NODE_ENV = "development"), ctx;
+    }
+    async function loader2(filepath) {
+      return req(filepath);
+    }
+    var yaml;
+    async function yamlLoader(_, content) {
+      if (!yaml)
+        try {
+          yaml = await import("../_node-chunks/dist-VTSTZKUB.js");
+        } catch (e) {
+          throw new Error(
+            `'yaml' is required for the YAML configuration files. Make sure it is installed
+Error: ${e.message}`
+          );
+        }
+      return yaml.parse(content);
+    }
+    var withLoaders2 = (options = {}) => {
+      let moduleName = "postcss";
+      return {
+        ...options,
+        loaders: {
+          ...options.loaders,
+          ".cjs": loader2,
+          ".cts": loader2,
+          ".js": loader2,
+          ".mjs": loader2,
+          ".mts": loader2,
+          ".ts": loader2,
+          ".yaml": yamlLoader,
+          ".yml": yamlLoader
+        },
+        searchPlaces: [
+          ...options.searchPlaces || [],
+          "package.json",
+          `.${moduleName}rc`,
+          `.${moduleName}rc.json`,
+          `.${moduleName}rc.yaml`,
+          `.${moduleName}rc.yml`,
+          `.${moduleName}rc.ts`,
+          `.${moduleName}rc.cts`,
+          `.${moduleName}rc.mts`,
+          `.${moduleName}rc.js`,
+          `.${moduleName}rc.cjs`,
+          `.${moduleName}rc.mjs`,
+          `${moduleName}.config.ts`,
+          `${moduleName}.config.cts`,
+          `${moduleName}.config.mts`,
+          `${moduleName}.config.js`,
+          `${moduleName}.config.cjs`,
+          `${moduleName}.config.mjs`
+        ]
+      };
+    };
+    function rc(ctx, path, options) {
+      return ctx = createContext(ctx), path = path ? resolve(path) : process.cwd(), config2.lilconfig("postcss", withLoaders2(options)).search(path).then((result) => {
+        if (!result)
+          throw new Error(`No PostCSS Config found in: ${path}`);
+        return processResult(ctx, result);
+      });
+    }
+    module.exports = rc;
+  }
+});
+
+// src/nextjs-vite/preset.ts
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import semver from "semver";
+import vitePluginStorybookNextjs from "@aussieljk/forkbook/internal/nextjs-vite-plugin";
+
+// src/nextjs-vite/find-postcss-config.ts
+var import_lilconfig = __toESM(require_src(), 1), import_postcss_load_config = __toESM(require_src2(), 1);
+import { readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { getProjectRoot } from "@aussieljk/forkbook/internal/common";
+import { IncompatiblePostCssConfigError } from "@aussieljk/forkbook/internal/server-errors";
+var require2 = createRequire(import.meta.url);
+async function loader(filepath) {
+  return require2(filepath);
+}
+var withLoaders = (options = {}) => {
+  let moduleName = "postcss";
+  return {
+    ...options,
+    loaders: {
+      ...options.loaders,
+      ".cjs": loader,
+      ".cts": loader,
+      ".js": loader,
+      ".mjs": loader,
+      ".mts": loader,
+      ".ts": loader
+    },
+    searchPlaces: [
+      ...options.searchPlaces ?? [],
+      "package.json",
+      `.${moduleName}rc`,
+      `.${moduleName}rc.json`,
+      `.${moduleName}rc.ts`,
+      `.${moduleName}rc.cts`,
+      `.${moduleName}rc.mts`,
+      `.${moduleName}rc.js`,
+      `.${moduleName}rc.cjs`,
+      `.${moduleName}rc.mjs`,
+      `${moduleName}.config.ts`,
+      `${moduleName}.config.cts`,
+      `${moduleName}.config.mts`,
+      `${moduleName}.config.js`,
+      `${moduleName}.config.cjs`,
+      `${moduleName}.config.mjs`
+    ]
+  };
+};
+async function postCssFindConfig(path, options = {}) {
+  let result = await import_lilconfig.default.lilconfig("postcss", withLoaders(options)).search(path);
+  return result ? result.filepath : null;
+}
+var normalizePostCssConfig = async (searchPath) => {
+  let configPath = await postCssFindConfig(searchPath);
+  if (!configPath)
+    return !0;
+  let error;
+  try {
+    return await (0, import_postcss_load_config.default)({}, searchPath, { stopDir: getProjectRoot() }), !0;
+  } catch (e) {
+    e instanceof Error && (error = e);
+  }
+  if (!error || error.message.includes("No PostCSS Config found"))
+    return !0;
+  if (error.message.includes("Invalid PostCSS Plugin found")) {
+    let originalContent = await readFile(configPath, "utf8");
+    try {
+      let modifiedContent = originalContent.replace(
+        'plugins: ["@tailwindcss/postcss"]',
+        'plugins: { "@tailwindcss/postcss": {} }'
+      );
+      return await writeFile(configPath, modifiedContent, "utf8"), await (0, import_postcss_load_config.default)({}, searchPath, { stopDir: getProjectRoot() }), !0;
+    } catch {
+      throw await writeFile(configPath, originalContent, "utf8"), new IncompatiblePostCssConfigError({ error });
+    }
+  }
+  return !1;
+};
+
+// src/nextjs-vite/utils.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var getNextjsVersion = () => JSON.parse(readFileSync(join(resolvePackageDir("next"), "package.json"), "utf8")).version;
+
+// src/nextjs-vite/preset.ts
+var core = {
+  builder: import.meta.resolve("@aussieljk/forkbook/builder-vite"),
+  renderer: import.meta.resolve("@aussieljk/forkbook/react/preset")
+}, previewAnnotations = (entry = []) => {
+  let annotations = [
+    ...entry,
+    fileURLToPath(import.meta.resolve("@aussieljk/forkbook/nextjs-vite/preview"))
+  ], nextjsVersion = getNextjsVersion();
+  return semver.gte(nextjsVersion, "16.0.0") || annotations.push(
+    fileURLToPath(import.meta.resolve("@aussieljk/forkbook/nextjs-vite/config/preview"))
+  ), annotations;
+}, optimizeViteDeps = [
+  "@aussieljk/forkbook/nextjs-vite/link.mock",
+  "@aussieljk/forkbook/nextjs-vite/navigation.mock",
+  "@aussieljk/forkbook/nextjs-vite/router.mock",
+  "@aussieljk/forkbook/nextjs-vite > styled-jsx",
+  "@aussieljk/forkbook/nextjs-vite > styled-jsx/style",
+  "@opentelemetry/api"
+], viteFinal = async (config2, options) => {
+  let inlineOptions = config2.css?.postcss, searchPath = typeof inlineOptions == "string" ? inlineOptions : config2.root;
+  searchPath && await normalizePostCssConfig(searchPath);
+  let { nextConfigPath, image = {} } = await options.presets.apply("frameworkOptions"), nextDir = nextConfigPath ? dirname(nextConfigPath) : void 0, vitePluginOptions = {
+    image,
+    dir: nextDir
+  };
+  return {
+    ...config2,
+    resolve: {
+      ...config2.resolve,
+      alias: {
+        ...config2.resolve?.alias,
+        "styled-jsx": dirname(fileURLToPath(import.meta.resolve("styled-jsx/package.json"))),
+        "styled-jsx/style": fileURLToPath(import.meta.resolve("styled-jsx/style")),
+        "styled-jsx/style.js": fileURLToPath(import.meta.resolve("styled-jsx/style"))
+      }
+    },
+    plugins: [...config2.plugins ?? [], vitePluginStorybookNextjs(vitePluginOptions)]
+  };
+};
+export {
+  core,
+  optimizeViteDeps,
+  previewAnnotations,
+  viteFinal
+};

package/dist/nextjs-vite/preview.d.ts

@@ -0,0 +1,20 @@
+import { Addon_DecoratorFunction, LoaderFunction } from "@aussieljk/forkbook/internal/types";
+import { ReactRenderer } from "@aussieljk/forkbook/react";
+
+//#region .dts-emit/code/core/src/nextjs-vite/preview.d.ts
+declare const decorators: Addon_DecoratorFunction<ReactRenderer>[];
+declare const loaders: LoaderFunction<ReactRenderer>;
+declare const parameters: {
+  docs: {
+    source: {
+      excludeDecorators: boolean;
+    };
+  };
+  react: {
+    rootOptions: {
+      onCaughtError(error: unknown): void;
+    };
+  };
+};
+//#endregion
+export { decorators, loaders, parameters };

package/dist/nextjs-vite/preview.js

@@ -0,0 +1,11 @@
+import {
+  decorators,
+  loaders,
+  parameters
+} from "../_browser-chunks/chunk-JSBKXXXF.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+export {
+  decorators,
+  loaders,
+  parameters
+};

package/dist/nextjs-vite/vite-plugin/index.d.ts

@@ -0,0 +1,6 @@
+import vitePluginStorybookNextjs from "@aussieljk/forkbook/internal/nextjs-vite-plugin";
+
+//#region .dts-emit/code/core/src/nextjs-vite/vite-plugin/index.d.ts
+declare const storybookNextJsPlugin: typeof vitePluginStorybookNextjs;
+//#endregion
+export { storybookNextJsPlugin };