@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/nextjs-vite-plugin/mocks/storybook.global.js

@@ -0,0 +1,29 @@
+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 {
+  getAlias,
+  getAlias2
+} from "../../_node-chunks/chunk-ZWBCQ4MJ.js";
+import "../../_node-chunks/chunk-CXRU72ET.js";
+
+// src/nextjs-vite-plugin/mocks/storybook.global.ts
+import { createRequire } from "node:module";
+import { addAliases } from "module-alias";
+var require2 = createRequire(import.meta.url);
+addAliases({
+  react: "next/dist/compiled/react",
+  "react-dom/server": "next/dist/compiled/react-dom/server.js",
+  "react-dom/test-utils": require2.resolve("next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js"),
+  "react-dom": "next/dist/compiled/react-dom",
+  ...getAlias2("node"),
+  ...getAlias("node")
+});

package/dist/nextjs-vite-plugin/plugins/next-image/alias/image-context.js

@@ -0,0 +1,8 @@
+import "../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-image/alias/image-context.tsx
+import { createContext } from "next/dist/compiled/react";
+var ImageContext = createContext({});
+export {
+  ImageContext
+};

package/dist/nextjs-vite-plugin/plugins/next-image/alias/image-default-loader.js

@@ -0,0 +1,23 @@
+import "../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-image/alias/image-default-loader.tsx
+var defaultLoader = ({ src, width, quality = 75 }) => {
+  let missingValues = [];
+  if (src || missingValues.push("src"), width || missingValues.push("width"), missingValues.length > 0)
+    throw new Error(
+      `Next Image Optimization requires ${missingValues.join(
+        ", "
+      )} to be provided. Make sure you pass them as props to the \`next/image\` component. Received: ${JSON.stringify(
+        {
+          src,
+          width,
+          quality
+        }
+      )}`
+    );
+  let url = new URL(src, window.location.href);
+  return !url.searchParams.has("w") && !url.searchParams.has("q") && (url.searchParams.set("w", width.toString()), url.searchParams.set("q", quality.toString())), !src.startsWith("http://") && !src.startsWith("https://") ? url.toString().slice(url.origin.length) : url.toString();
+};
+export {
+  defaultLoader
+};

package/dist/nextjs-vite-plugin/plugins/next-image/alias/next-image.js

@@ -0,0 +1,28 @@
+import "../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-image/alias/next-image.tsx
+import * as NextImageNamespace from "next/image";
+import { defaultLoader } from "sb-original/default-loader";
+import { ImageContext } from "sb-original/image-context";
+import React from "next/dist/compiled/react";
+import { jsx } from "react/jsx-runtime";
+var _raw = NextImageNamespace.default, OriginalNextImage = typeof _raw == "object" && _raw !== null && "__esModule" in _raw ? _raw.default : _raw, originalGetImageProps = NextImageNamespace.getImageProps ?? (typeof _raw == "object" && _raw !== null && "getImageProps" in _raw ? _raw.getImageProps : void 0), MockedNextImage = React.forwardRef(
+  ({ loader, ...props }, ref) => {
+    let imageParameters = React.useContext(ImageContext);
+    return jsx(
+      OriginalNextImage,
+      {
+        ref,
+        ...imageParameters,
+        ...props,
+        loader: loader ?? defaultLoader
+      }
+    );
+  }
+);
+MockedNextImage.displayName = "NextImage";
+var getImageProps2 = (props) => originalGetImageProps?.({ loader: defaultLoader, ...props }), next_image_default = MockedNextImage;
+export {
+  next_image_default as default,
+  getImageProps2 as getImageProps
+};

package/dist/nextjs-vite-plugin/plugins/next-image/alias/next-legacy-image.js

@@ -0,0 +1,17 @@
+import "../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-image/alias/next-legacy-image.tsx
+import * as _NextLegacyImageNamespace from "next/legacy/image";
+import { defaultLoader } from "sb-original/default-loader";
+import { ImageContext } from "sb-original/image-context";
+import React from "next/dist/compiled/react";
+import { jsx } from "react/jsx-runtime";
+var _rawLegacy = _NextLegacyImageNamespace.default, OriginalNextLegacyImage = typeof _rawLegacy == "object" && _rawLegacy !== null && "__esModule" in _rawLegacy ? _rawLegacy.default : _rawLegacy;
+function NextLegacyImage({ loader, ...props }) {
+  let imageParameters = React.useContext(ImageContext);
+  return jsx(OriginalNextLegacyImage, { ...imageParameters, ...props, loader: loader ?? defaultLoader });
+}
+var next_legacy_image_default = NextLegacyImage;
+export {
+  next_legacy_image_default as default
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/cache/index.js

@@ -0,0 +1,29 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/cache/index.ts
+import { fn } from "@aussieljk/forkbook/test";
+var revalidatePath = fn().mockName("next/cache::revalidatePath"), revalidateTag = fn().mockName("next/cache::revalidateTag"), updateTag = fn().mockName("next/cache::updateTag"), unstable_cache = fn().mockName("next/cache::unstable_cache").mockImplementation((cb) => cb), unstable_noStore = fn().mockName("next/cache::unstable_noStore"), refresh = fn().mockName("next/cache::refresh"), cacheLife = fn().mockName("next/cache::cacheLife"), cacheTag = fn().mockName("next/cache::cacheTag"), unstable_cacheLife = cacheLife, unstable_cacheTag = cacheTag, cacheExports = {
+  unstable_cache,
+  revalidateTag,
+  revalidatePath,
+  updateTag,
+  refresh,
+  unstable_noStore,
+  cacheLife,
+  cacheTag,
+  unstable_cacheLife,
+  unstable_cacheTag
+}, cache_default = cacheExports;
+export {
+  cacheLife,
+  cacheTag,
+  cache_default as default,
+  refresh,
+  revalidatePath,
+  revalidateTag,
+  unstable_cache,
+  unstable_cacheLife,
+  unstable_cacheTag,
+  unstable_noStore,
+  updateTag
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/dynamic/index.js

@@ -0,0 +1,40 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/dynamic/index.tsx
+import Loadable from "next/dist/shared/lib/loadable.shared-runtime.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+function convertModule(mod) {
+  return { default: mod?.default || mod };
+}
+function noSSR() {
+  throw new Error("noSSR is not implemented in Forkbook");
+}
+function dynamic(dynamicOptions, options) {
+  let loadableFn = Loadable?.default ?? Loadable, loadableOptions = {
+    // A loading component is not required, so we default it
+    loading: ({ error, isLoading, pastDelay }) => {
+      if (!pastDelay) return null;
+      if (process.env.NODE_ENV !== "production") {
+        if (isLoading)
+          return null;
+        if (error)
+          return jsxs("p", { children: [
+            error.message,
+            jsx("br", {}),
+            error.stack
+          ] });
+      }
+      return null;
+    }
+  };
+  dynamicOptions instanceof Promise ? loadableOptions.loader = () => dynamicOptions : typeof dynamicOptions == "function" ? loadableOptions.loader = dynamicOptions : typeof dynamicOptions == "object" && (loadableOptions = { ...loadableOptions, ...dynamicOptions }), loadableOptions = { ...loadableOptions, ...options };
+  let loaderFn = loadableOptions.loader, loader = () => loaderFn != null ? loaderFn().then(convertModule) : Promise.resolve(convertModule(() => null));
+  return loadableOptions.loadableGenerated && (loadableOptions = {
+    ...loadableOptions,
+    ...loadableOptions.loadableGenerated
+  }, delete loadableOptions.loadableGenerated), typeof loadableOptions.ssr == "boolean" && !loadableOptions.ssr && (delete loadableOptions.ssr, delete loadableOptions.webpack, delete loadableOptions.modules), loadableFn({ ...loadableOptions, loader });
+}
+export {
+  dynamic as default,
+  noSSR
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/headers/index.js

@@ -0,0 +1,55 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/headers/index.ts
+import { draftMode as originalDraftMode } from "next/dist/server/request/draft-mode";
+import * as headersModule from "next/dist/server/request/headers";
+import { fn as fn3 } from "@aussieljk/forkbook/test";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/headers/headers.ts
+import { HeadersAdapter } from "next/dist/server/web/spec-extension/adapters/headers.js";
+import { fn } from "@aussieljk/forkbook/test";
+var HeadersAdapterMock = class extends HeadersAdapter {
+  constructor() {
+    super({});
+    this.append = fn(super.append.bind(this)).mockName("next/headers::headers().append");
+    this.delete = fn(super.delete.bind(this)).mockName("next/headers::headers().delete");
+    this.get = fn(super.get.bind(this)).mockName("next/headers::headers().get");
+    this.has = fn(super.has.bind(this)).mockName("next/headers::headers().has");
+    this.set = fn(super.set.bind(this)).mockName("next/headers::headers().set");
+    this.forEach = fn(super.forEach.bind(this)).mockName("next/headers::headers().forEach");
+    this.entries = fn(super.entries.bind(this)).mockName("next/headers::headers().entries");
+    this.keys = fn(super.keys.bind(this)).mockName("next/headers::headers().keys");
+    this.values = fn(super.values.bind(this)).mockName("next/headers::headers().values");
+  }
+}, headersAdapterMock, headers = () => (headersAdapterMock || (headersAdapterMock = new HeadersAdapterMock()), headersAdapterMock);
+headers.mockRestore = () => {
+  headersAdapterMock = new HeadersAdapterMock();
+};
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/headers/cookies.ts
+import { RequestCookies } from "next/dist/compiled/@edge-runtime/cookies/index.js";
+import { fn as fn2 } from "@aussieljk/forkbook/test";
+var RequestCookiesMock = class extends RequestCookies {
+  constructor() {
+    super(...arguments);
+    this.get = fn2(super.get.bind(this)).mockName("next/headers::cookies().get");
+    this.getAll = fn2(super.getAll.bind(this)).mockName("next/headers::cookies().getAll");
+    this.has = fn2(super.has.bind(this)).mockName("next/headers::cookies().has");
+    this.set = fn2(super.set.bind(this)).mockName("next/headers::cookies().set");
+    this.delete = fn2(super.delete.bind(this)).mockName("next/headers::cookies().delete");
+  }
+}, requestCookiesMock, cookies = fn2(() => (requestCookiesMock || (requestCookiesMock = new RequestCookiesMock(headers())), requestCookiesMock)).mockName("next/headers::cookies()"), originalRestore = cookies.mockRestore.bind(null);
+cookies.mockRestore = () => {
+  originalRestore(), headers.mockRestore(), requestCookiesMock = new RequestCookiesMock(headers());
+};
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/headers/index.ts
+var draftMode2 = fn3(
+  // draftMode lived on the headers module in older Next versions
+  originalDraftMode ?? headersModule.draftMode
+).mockName("draftMode");
+export {
+  cookies,
+  draftMode2 as draftMode,
+  headers
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/link/index.js

@@ -0,0 +1,63 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/link/index.tsx
+import React from "react";
+import { fn } from "@aussieljk/forkbook/test";
+import { jsx } from "react/jsx-runtime";
+var linkAction = fn().mockName("next/link::Link"), removeTrailingSlash = (route) => route.endsWith("/") && route.length > 1 ? route.slice(0, -1) : route, parsePath = (path) => {
+  let hashIndex = path.indexOf("#"), queryIndex = path.indexOf("?"), hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+  return hasQuery || hashIndex > -1 ? {
+    pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+    query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : void 0) : "",
+    hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+  } : { pathname: path, query: "", hash: "" };
+}, normalizePathTrailingSlash = (path) => {
+  if (!path.startsWith("/") || process.env.__NEXT_MANUAL_TRAILING_SLASH)
+    return path;
+  let { pathname, query, hash } = parsePath(path);
+  return process.env.__NEXT_TRAILING_SLASH ? /\.[^/]+\/?$/.test(pathname) ? `${removeTrailingSlash(pathname)}${query}${hash}` : `${pathname.endsWith("/") ? pathname : `${pathname}/`}${query}${hash}` : `${removeTrailingSlash(pathname)}${query}${hash}`;
+}, MockLink = React.forwardRef(function({
+  href,
+  as: _as,
+  replace,
+  scroll,
+  shallow,
+  prefetch,
+  passHref,
+  legacyBehavior,
+  locale,
+  onClick,
+  children,
+  ...rest
+}, ref) {
+  let rawHref = typeof href == "object" ? `${href.pathname || ""}${href.query ? `?${new URLSearchParams(href.query).toString()}` : ""}${href.hash || ""}` : href, hrefString = typeof rawHref == "string" ? normalizePathTrailingSlash(rawHref) : rawHref, handleClick = (e) => {
+    e.preventDefault(), onClick?.(e), linkAction(hrefString, { replace, scroll, shallow, prefetch, locale });
+  };
+  if (legacyBehavior) {
+    let child = React.Children.only(children), childProps = {
+      ref,
+      onClick: (e) => {
+        e.preventDefault(), child.props && typeof child.props.onClick == "function" && child.props.onClick(e), linkAction(hrefString, {
+          replace,
+          scroll,
+          shallow,
+          prefetch,
+          locale
+        });
+      },
+      ...rest
+    };
+    return (passHref || child.type === "a" && !("href" in (child.props || {}))) && (childProps.href = hrefString), React.cloneElement(child, childProps);
+  }
+  return jsx("a", { ref, href: hrefString, onClick: handleClick, ...rest, children });
+});
+MockLink.displayName = "NextLink";
+var link_default = MockLink;
+var useLinkStatus = fn(() => ({
+  pending: !1
+})).mockName("next/link::useLinkStatus");
+export {
+  MockLink as Link,
+  link_default as default,
+  useLinkStatus
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/navigation/index.js

@@ -0,0 +1,71 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/navigation/index.ts
+import * as actual from "next/dist/client/components/navigation.js";
+import { RedirectStatusCode } from "next/dist/client/components/redirect-status-code.js";
+import { getRedirectError } from "next/dist/client/components/redirect.js";
+import { NextjsRouterMocksNotAvailable } from "@aussieljk/forkbook/internal/preview-errors";
+import { fn } from "@aussieljk/forkbook/test";
+export * from "next/dist/client/components/navigation.js";
+import {
+  ReadonlyURLSearchParams,
+  RedirectType,
+  ServerInsertedHTMLContext
+} from "next/dist/client/components/navigation.js";
+var navigationAPI, createNavigation = (overrides) => {
+  let navigationActions = {
+    push: fn().mockName("next/navigation::useRouter().push"),
+    replace: fn().mockName("next/navigation::useRouter().replace"),
+    forward: fn().mockName("next/navigation::useRouter().forward"),
+    back: fn().mockName("next/navigation::useRouter().back"),
+    prefetch: fn().mockName("next/navigation::useRouter().prefetch"),
+    refresh: fn().mockName("next/navigation::useRouter().refresh")
+  };
+  if (overrides)
+    for (let key of Object.keys(navigationActions))
+      key in overrides && (navigationActions[key] = fn((...args) => overrides[key](...args)).mockName(`useRouter().${key}`));
+  return navigationAPI = navigationActions, navigationAPI;
+}, getRouter = () => {
+  if (!navigationAPI)
+    throw new NextjsRouterMocksNotAvailable({
+      importType: "next/navigation"
+    });
+  return navigationAPI;
+}, forbidden2 = actual.forbidden, unauthorized2 = actual.unauthorized, unstable_isUnrecognizedActionError2 = actual.unstable_isUnrecognizedActionError, redirect = fn((url, type = "push") => {
+  throw getRedirectError(url, type, RedirectStatusCode.SeeOther);
+}).mockName("next/navigation::redirect"), permanentRedirect = fn(
+  (url, type = "push") => {
+    throw getRedirectError(url, type, RedirectStatusCode.SeeOther);
+  }
+).mockName("next/navigation::permanentRedirect"), useSearchParams2 = fn(actual.useSearchParams).mockName(
+  "next/navigation::useSearchParams"
+), usePathname2 = fn(actual.usePathname).mockName("next/navigation::usePathname"), useSelectedLayoutSegment2 = fn(actual.useSelectedLayoutSegment).mockName(
+  "next/navigation::useSelectedLayoutSegment"
+), useSelectedLayoutSegments2 = fn(actual.useSelectedLayoutSegments).mockName(
+  "next/navigation::useSelectedLayoutSegments"
+), useRouter2 = fn(actual.useRouter).mockName("next/navigation::useRouter"), useServerInsertedHTML2 = fn(actual.useServerInsertedHTML).mockName(
+  "next/navigation::useServerInsertedHTML"
+), notFound2 = fn(actual.notFound).mockName("next/navigation::notFound"), unstable_rethrow2 = fn(actual.unstable_rethrow).mockName(
+  "next/navigation::unstable_rethrow"
+), useParams2 = fn(actual.useParams).mockName("next/navigation::useParams");
+export {
+  ReadonlyURLSearchParams,
+  RedirectType,
+  ServerInsertedHTMLContext,
+  createNavigation,
+  forbidden2 as forbidden,
+  getRouter,
+  notFound2 as notFound,
+  permanentRedirect,
+  redirect,
+  unauthorized2 as unauthorized,
+  unstable_isUnrecognizedActionError2 as unstable_isUnrecognizedActionError,
+  unstable_rethrow2 as unstable_rethrow,
+  useParams2 as useParams,
+  usePathname2 as usePathname,
+  useRouter2 as useRouter,
+  useSearchParams2 as useSearchParams,
+  useSelectedLayoutSegment2 as useSelectedLayoutSegment,
+  useSelectedLayoutSegments2 as useSelectedLayoutSegments,
+  useServerInsertedHTML2 as useServerInsertedHTML
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/router/index.js

@@ -0,0 +1,74 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/router/index.ts
+import singletonRouter, * as originalRouter from "next/dist/client/router.js";
+import { NextjsRouterMocksNotAvailable } from "@aussieljk/forkbook/internal/preview-errors";
+import { fn } from "@aussieljk/forkbook/test";
+export * from "next/dist/client/router";
+import { Router } from "next/dist/client/router";
+var defaultRouterState = {
+  route: "/",
+  asPath: "/",
+  basePath: "/",
+  pathname: "/",
+  query: {},
+  isFallback: !1,
+  isLocaleDomain: !1,
+  isReady: !0,
+  isPreview: !1
+}, routerAPI, createRouter = (overrides) => {
+  let routerActions = {
+    push: fn((..._args) => Promise.resolve(!0)).mockName("next/router::useRouter().push"),
+    replace: fn((..._args) => Promise.resolve(!0)).mockName("next/router::useRouter().replace"),
+    reload: fn((..._args) => {
+    }).mockName("next/router::useRouter().reload"),
+    back: fn((..._args) => {
+    }).mockName("next/router::useRouter().back"),
+    forward: fn(() => {
+    }).mockName("next/router::useRouter().forward"),
+    prefetch: fn((..._args) => Promise.resolve()).mockName("next/router::useRouter().prefetch"),
+    beforePopState: fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().beforePopState"
+    )
+  }, routerEvents = {
+    on: fn((..._args) => {
+    }).mockName("next/router::useRouter().events.on"),
+    off: fn((..._args) => {
+    }).mockName("next/router::useRouter().events.off"),
+    emit: fn((..._args) => {
+    }).mockName("next/router::useRouter().events.emit")
+  };
+  if (overrides)
+    for (let key of Object.keys(routerActions))
+      key in overrides && (routerActions[key] = fn((...args) => overrides[key](...args)).mockName(`useRouter().${key}`));
+  if (overrides?.events)
+    for (let key of Object.keys(routerEvents))
+      key in routerEvents && (routerEvents[key] = fn((...args) => overrides.events[key](...args)).mockName(`useRouter().events.${key}`));
+  routerAPI = {
+    ...defaultRouterState,
+    ...overrides,
+    ...routerActions,
+    // @ts-expect-error TODO improve typings
+    events: routerEvents
+  }, singletonRouter.router = routerAPI;
+  for (let cb of singletonRouter.readyCallbacks)
+    cb();
+  return singletonRouter.readyCallbacks = [], routerAPI;
+}, getRouter = () => {
+  if (!routerAPI)
+    throw new NextjsRouterMocksNotAvailable({
+      importType: "next/router"
+    });
+  return routerAPI;
+}, router_default = singletonRouter, useRouter2 = fn(originalRouter.useRouter).mockName(
+  "next/router::useRouter"
+), withRouter2 = fn(originalRouter.withRouter).mockName("next/router::withRouter");
+export {
+  Router,
+  createRouter,
+  router_default as default,
+  getRouter,
+  useRouter2 as useRouter,
+  withRouter2 as withRouter
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/rsc/server-only.js

@@ -0,0 +1,7 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/rsc/server-only.ts
+var server_only_default = {};
+export {
+  server_only_default as default
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/alias/safe-stable-stringify/index.js

@@ -0,0 +1,13 @@
+import "../../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/alias/safe-stable-stringify/index.ts
+function safeStableStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+export {
+  safeStableStringify as default
+};

package/dist/nextjs-vite-plugin/plugins/next-mocks/compatibility/draft-mode.compat.js

@@ -0,0 +1,7 @@
+import "../../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/nextjs-vite-plugin/plugins/next-mocks/compatibility/draft-mode.compat.ts
+import { draftMode } from "next/dist/client/components/headers";
+export {
+  draftMode
+};