@storybook/nextjs-vite/dist/_browser-chunks/chunk-37RBXWOJ.js

Storybook for Next.js and Vite: Develop, document, and test UI components in isolation

import {
  __export
} from "./chunk-SL3VIQZ3.js";

// src/preview.tsx
var preview_exports = {};
__export(preview_exports, {
  decorators: () => decorators,
  loaders: () => loaders,
  parameters: () => parameters
});
import { createNavigation } from "@storybook/nextjs-vite/navigation.mock";
import { createRouter } from "@storybook/nextjs-vite/router.mock";
import { isNextRouterError } from "next/dist/client/components/is-next-router-error";

// src/head-manager/decorator.tsx
import * as React2 from "react";

// src/head-manager/head-manager-provider.tsx
import React, { useMemo } from "react";
import initHeadManager from "next/dist/client/head-manager";
import { HeadManagerContext } from "next/dist/shared/lib/head-manager-context.shared-runtime";
var HeadManagerProvider = ({ children }) => {
  let headManager = useMemo(initHeadManager, []);
  return headManager.getIsSsr = () => !1, React.createElement(HeadManagerContext.Provider, { value: headManager }, children);
}, head_manager_provider_default = HeadManagerProvider;

// src/head-manager/decorator.tsx
var HeadManagerDecorator = (Story) => React2.createElement(head_manager_provider_default, null, React2.createElement(Story, null));

// src/images/decorator.tsx
import * as React3 from "react";
import { ImageContext } from "sb-original/image-context";
var ImageDecorator = (Story, { parameters: parameters2 }) => parameters2.nextjs?.image ? React3.createElement(ImageContext.Provider, { value: parameters2.nextjs.image }, React3.createElement(Story, null)) : React3.createElement(Story, null);

// src/routing/decorator.tsx
import * as React6 from "react";
import { RedirectBoundary } from "next/dist/client/components/redirect-boundary";

// src/routing/app-router-provider.tsx
import React4, { useMemo as useMemo2 } from "react";
import { getRouter } from "@storybook/nextjs-vite/navigation.mock";
import {
  AppRouterContext,
  GlobalLayoutRouterContext,
  LayoutRouterContext
} from "next/dist/shared/lib/app-router-context.shared-runtime";
import {
  PathParamsContext,
  PathnameContext,
  SearchParamsContext
} from "next/dist/shared/lib/hooks-client-context.shared-runtime";
import { PAGE_SEGMENT_KEY } from "next/dist/shared/lib/segment";
var getParallelRoutes = (segmentsList) => {
  let segment = segmentsList.shift();
  return segment ? [segment, { children: getParallelRoutes(segmentsList) }] : [];
}, AppRouterProvider = ({
  children,
  routeParams
}) => {
  let { pathname, query, segments = [] } = routeParams, tree = [pathname, { children: getParallelRoutes([...segments]) }], pathParams = useMemo2(() => {
    let params = {}, currentSegments = routeParams.segments;
    if (currentSegments) {
      if (Array.isArray(currentSegments)) {
        for (let segmentEntry of currentSegments)
          if (Array.isArray(segmentEntry) && segmentEntry.length === 2 && typeof segmentEntry[0] == "string") {
            let key = segmentEntry[0], value = segmentEntry[1];
            params[key] = value;
          }
      } else if (typeof currentSegments == "object" && !Array.isArray(currentSegments)) {
        let segmentObject = currentSegments;
        for (let key in segmentObject)
          Object.prototype.hasOwnProperty.call(segmentObject, key) && (params[key] = segmentObject[key]);
      }
    }
    return params;
  }, [routeParams.segments]), newLazyCacheNode = {
    lazyData: null,
    rsc: null,
    prefetchRsc: null,
    head: null,
    prefetchHead: null,
    parallelRoutes: /* @__PURE__ */ new Map(),
    loading: null
  };
  return React4.createElement(PathParamsContext.Provider, { value: pathParams }, React4.createElement(PathnameContext.Provider, { value: pathname }, React4.createElement(SearchParamsContext.Provider, { value: new URLSearchParams(query) }, React4.createElement(
    GlobalLayoutRouterContext.Provider,
    {
      value: {
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore (Only available in Next.js >= v15.1.1)
        changeByServerResponse() {
        },
        buildId: "storybook",
        tree,
        focusAndScrollRef: {
          apply: !1,
          hashFragment: null,
          segmentPaths: [tree],
          onlyHashChange: !1
        },
        nextUrl: pathname
      }
    },
    React4.createElement(AppRouterContext.Provider, { value: getRouter() }, React4.createElement(
      LayoutRouterContext.Provider,
      {
        value: {
          // TODO Remove when dropping Next.js < v15.1.1
          childNodes: /* @__PURE__ */ new Map(),
          tree,
          // TODO END
          // START Next.js v15.2 support
          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
          // @ts-ignore Only available in Next.js >= v15.1.1
          parentTree: tree,
          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
          // @ts-ignore Only available in Next.js >= v15.1.1
          parentCacheNode: newLazyCacheNode,
          // END
          url: pathname,
          loading: null
        }
      },
      children
    ))
  ))));
};

// src/routing/page-router-provider.tsx
import React5 from "react";
import { getRouter as getRouter2 } from "@storybook/nextjs-vite/router.mock";
import { RouterContext } from "next/dist/shared/lib/router-context.shared-runtime";
var PageRouterProvider = ({ children }) => React5.createElement(RouterContext.Provider, { value: getRouter2() }, children);

// src/routing/decorator.tsx
var defaultRouterParams = {
  pathname: "/",
  query: {}
}, RouterDecorator = (Story, { parameters: parameters2 }) => parameters2.nextjs?.appDirectory ?? !1 ? AppRouterProvider ? React6.createElement(
  AppRouterProvider,
  {
    routeParams: {
      ...defaultRouterParams,
      ...parameters2.nextjs?.navigation
    }
  },
  React6.createElement(RedirectBoundary, null, React6.createElement(Story, null))
) : null : React6.createElement(PageRouterProvider, null, React6.createElement(Story, null));

// src/styledJsx/decorator.tsx
import * as React7 from "react";
import { StyleRegistry } from "styled-jsx";
var StyledJsxDecorator = (Story) => React7.createElement(StyleRegistry, null, React7.createElement(Story, null));

// src/preview.tsx
function addNextHeadCount() {
  let meta = document.createElement("meta");
  meta.name = "next-head-count", meta.content = "0", document.head.appendChild(meta);
}
function isAsyncClientComponentError(error) {
  return typeof error == "string" && (error.includes("Only Server Components can be async at the moment.") || error.includes("A component was suspended by an uncached promise.") || error.includes("async/await is not yet supported in Client Components"));
}
addNextHeadCount();
var origConsoleError = globalThis.console.error;
globalThis.console.error = (...args) => {
  let error = args[0];
  isNextRouterError(error) || isAsyncClientComponentError(error) || origConsoleError.apply(globalThis.console, args);
};
globalThis.addEventListener("error", (ev) => {
  if (isNextRouterError(ev.error) || isAsyncClientComponentError(ev.error)) {
    ev.preventDefault();
    return;
  }
});
var asDecorator = (decorator) => decorator, decorators = [
  asDecorator(StyledJsxDecorator),
  asDecorator(ImageDecorator),
  asDecorator(RouterDecorator),
  asDecorator(HeadManagerDecorator)
], loaders = async ({ globals, parameters: parameters2 }) => {
  let { router, appDirectory } = parameters2.nextjs ?? {};
  appDirectory ? createNavigation(router) : createRouter({
    locale: globals.locale,
    ...router
  });
}, parameters = {
  docs: {
    source: {
      excludeDecorators: !0
    }
  },
  react: {
    rootOptions: {
      onCaughtError(error) {
        isNextRouterError(error) || console.error(error);
      }
    }
  }
};

export {
  decorators,
  loaders,
  parameters,
  preview_exports
};