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

package/dist/plugins/next-mocks/alias/cache/index.d.cts

@@ -0,0 +1,16 @@
+import * as vitest from 'vitest';
+import { unstable_cache } from 'next/dist/server/web/spec-extension/unstable-cache.js';
+export { unstable_cache } from 'next/dist/server/web/spec-extension/unstable-cache.js';
+import { unstable_noStore } from 'next/dist/server/web/spec-extension/unstable-no-store.js';
+export { unstable_noStore } from 'next/dist/server/web/spec-extension/unstable-no-store.js';
+
+declare const revalidatePath: vitest.Mock<any, any>;
+declare const revalidateTag: vitest.Mock<any, any>;
+declare const cacheExports: {
+    unstable_cache: typeof unstable_cache;
+    revalidateTag: vitest.Mock<any, any>;
+    revalidatePath: vitest.Mock<any, any>;
+    unstable_noStore: typeof unstable_noStore;
+};
+
+export { cacheExports as default, revalidatePath, revalidateTag };

package/dist/plugins/next-mocks/alias/headers/cookies.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var test = require('@storybook/test');
+var index_js = require('next/dist/compiled/@edge-runtime/cookies/index.js');
+var originalHeaders = require('next/dist/client/components/headers.js');
+var headers_js = require('next/dist/server/web/spec-extension/adapters/headers.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var originalHeaders__namespace = /*#__PURE__*/_interopNamespace(originalHeaders);
+
+// src/plugins/next-mocks/alias/headers/cookies.ts
+var HeadersAdapterMock = class extends headers_js.HeadersAdapter {
+  constructor() {
+    super({});
+    this.append = test.fn(super.append.bind(this)).mockName(
+      "next/headers::headers().append"
+    );
+    this.delete = test.fn(super.delete.bind(this)).mockName(
+      "next/headers::headers().delete"
+    );
+    this.get = test.fn(super.get.bind(this)).mockName("next/headers::headers().get");
+    this.has = test.fn(super.has.bind(this)).mockName("next/headers::headers().has");
+    this.set = test.fn(super.set.bind(this)).mockName("next/headers::headers().set");
+    this.forEach = test.fn(super.forEach.bind(this)).mockName(
+      "next/headers::headers().forEach"
+    );
+    this.entries = test.fn(super.entries.bind(this)).mockName(
+      "next/headers::headers().entries"
+    );
+    this.keys = test.fn(super.keys.bind(this)).mockName("next/headers::headers().keys");
+    this.values = test.fn(super.values.bind(this)).mockName(
+      "next/headers::headers().values"
+    );
+  }
+};
+var headersAdapterMock;
+var headers = () => {
+  if (!headersAdapterMock) headersAdapterMock = new HeadersAdapterMock();
+  return headersAdapterMock;
+};
+headers.mockRestore = () => {
+  headersAdapterMock = new HeadersAdapterMock();
+};
+
+// src/plugins/next-mocks/alias/headers/index.ts
+test.fn(originalHeaders__namespace.draftMode).mockName("draftMode");
+
+// src/plugins/next-mocks/alias/headers/cookies.ts
+var RequestCookiesMock = class extends index_js.RequestCookies {
+  constructor() {
+    super(...arguments);
+    this.get = test.fn(super.get.bind(this)).mockName("next/headers::cookies().get");
+    this.getAll = test.fn(super.getAll.bind(this)).mockName(
+      "next/headers::cookies().getAll"
+    );
+    this.has = test.fn(super.has.bind(this)).mockName("next/headers::cookies().has");
+    this.set = test.fn(super.set.bind(this)).mockName("next/headers::cookies().set");
+    this.delete = test.fn(super.delete.bind(this)).mockName(
+      "next/headers::cookies().delete"
+    );
+  }
+};
+var requestCookiesMock;
+var cookies = test.fn(() => {
+  if (!requestCookiesMock) {
+    requestCookiesMock = new RequestCookiesMock(headers());
+  }
+  return requestCookiesMock;
+}).mockName("next/headers::cookies()");
+var originalRestore = cookies.mockRestore.bind(null);
+cookies.mockRestore = () => {
+  originalRestore();
+  headers.mockRestore();
+  requestCookiesMock = new RequestCookiesMock(headers());
+};
+
+exports.cookies = cookies;

package/dist/plugins/next-mocks/alias/headers/cookies.d.cts

@@ -0,0 +1,14 @@
+import * as vitest from 'vitest';
+import * as next_dist_compiled__edge_runtime_cookies from 'next/dist/compiled/@edge-runtime/cookies';
+import { RequestCookies } from 'next/dist/compiled/@edge-runtime/cookies/index.js';
+
+declare class RequestCookiesMock extends RequestCookies {
+    get: vitest.Mock<[name: string] | [next_dist_compiled__edge_runtime_cookies.RequestCookie], next_dist_compiled__edge_runtime_cookies.RequestCookie | undefined>;
+    getAll: vitest.Mock<[next_dist_compiled__edge_runtime_cookies.RequestCookie] | [name: string] | [], next_dist_compiled__edge_runtime_cookies.RequestCookie[]>;
+    has: vitest.Mock<[name: string], boolean>;
+    set: vitest.Mock<[key: string, value: string] | [options: next_dist_compiled__edge_runtime_cookies.RequestCookie], this>;
+    delete: vitest.Mock<[names: string | string[]], boolean | boolean[]>;
+}
+declare const cookies: vitest.Mock<[], RequestCookiesMock>;
+
+export { cookies };

package/dist/plugins/next-mocks/alias/headers/cookies.d.ts

@@ -4,7 +4,7 @@ import { RequestCookies } from 'next/dist/compiled/@edge-runtime/cookies/index.j
 
 declare class RequestCookiesMock extends RequestCookies {
     get: vitest.Mock<[name: string] | [next_dist_compiled__edge_runtime_cookies.RequestCookie], next_dist_compiled__edge_runtime_cookies.RequestCookie | undefined>;
-    getAll: vitest.Mock<[] | [next_dist_compiled__edge_runtime_cookies.RequestCookie] | [name: string], next_dist_compiled__edge_runtime_cookies.RequestCookie[]>;
+    getAll: vitest.Mock<[next_dist_compiled__edge_runtime_cookies.RequestCookie] | [name: string] | [], next_dist_compiled__edge_runtime_cookies.RequestCookie[]>;
     has: vitest.Mock<[name: string], boolean>;
     set: vitest.Mock<[key: string, value: string] | [options: next_dist_compiled__edge_runtime_cookies.RequestCookie], this>;
     delete: vitest.Mock<[names: string | string[]], boolean | boolean[]>;

package/dist/plugins/next-mocks/alias/headers/headers.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var test = require('@storybook/test');
+var headers_js = require('next/dist/server/web/spec-extension/adapters/headers.js');
+
+// src/plugins/next-mocks/alias/headers/headers.ts
+var HeadersAdapterMock = class extends headers_js.HeadersAdapter {
+  constructor() {
+    super({});
+    this.append = test.fn(super.append.bind(this)).mockName(
+      "next/headers::headers().append"
+    );
+    this.delete = test.fn(super.delete.bind(this)).mockName(
+      "next/headers::headers().delete"
+    );
+    this.get = test.fn(super.get.bind(this)).mockName("next/headers::headers().get");
+    this.has = test.fn(super.has.bind(this)).mockName("next/headers::headers().has");
+    this.set = test.fn(super.set.bind(this)).mockName("next/headers::headers().set");
+    this.forEach = test.fn(super.forEach.bind(this)).mockName(
+      "next/headers::headers().forEach"
+    );
+    this.entries = test.fn(super.entries.bind(this)).mockName(
+      "next/headers::headers().entries"
+    );
+    this.keys = test.fn(super.keys.bind(this)).mockName("next/headers::headers().keys");
+    this.values = test.fn(super.values.bind(this)).mockName(
+      "next/headers::headers().values"
+    );
+  }
+};
+var headersAdapterMock;
+var headers = () => {
+  if (!headersAdapterMock) headersAdapterMock = new HeadersAdapterMock();
+  return headersAdapterMock;
+};
+headers.mockRestore = () => {
+  headersAdapterMock = new HeadersAdapterMock();
+};
+
+exports.headers = headers;

package/dist/plugins/next-mocks/alias/headers/headers.d.cts

@@ -0,0 +1,21 @@
+import * as vitest from 'vitest';
+import { HeadersAdapter } from 'next/dist/server/web/spec-extension/adapters/headers.js';
+
+declare class HeadersAdapterMock extends HeadersAdapter {
+    constructor();
+    append: vitest.Mock<[name: string, value: string], void>;
+    delete: vitest.Mock<[name: string], void>;
+    get: vitest.Mock<[name: string], string | null>;
+    has: vitest.Mock<[name: string], boolean>;
+    set: vitest.Mock<[name: string, value: string], void>;
+    forEach: vitest.Mock<[callbackfn: (value: string, name: string, parent: Headers) => void, thisArg?: any], void>;
+    entries: vitest.Mock<[], IterableIterator<[string, string]>>;
+    keys: vitest.Mock<[], IterableIterator<string>>;
+    values: vitest.Mock<[], IterableIterator<string>>;
+}
+declare const headers: {
+    (): HeadersAdapterMock;
+    mockRestore(): void;
+};
+
+export { headers };

package/dist/plugins/next-mocks/alias/headers/index.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var test = require('@storybook/test');
+var originalHeaders = require('next/dist/client/components/headers.js');
+var headers_js = require('next/dist/server/web/spec-extension/adapters/headers.js');
+var index_js = require('next/dist/compiled/@edge-runtime/cookies/index.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var originalHeaders__namespace = /*#__PURE__*/_interopNamespace(originalHeaders);
+
+// src/plugins/next-mocks/alias/headers/index.ts
+var HeadersAdapterMock = class extends headers_js.HeadersAdapter {
+  constructor() {
+    super({});
+    this.append = test.fn(super.append.bind(this)).mockName(
+      "next/headers::headers().append"
+    );
+    this.delete = test.fn(super.delete.bind(this)).mockName(
+      "next/headers::headers().delete"
+    );
+    this.get = test.fn(super.get.bind(this)).mockName("next/headers::headers().get");
+    this.has = test.fn(super.has.bind(this)).mockName("next/headers::headers().has");
+    this.set = test.fn(super.set.bind(this)).mockName("next/headers::headers().set");
+    this.forEach = test.fn(super.forEach.bind(this)).mockName(
+      "next/headers::headers().forEach"
+    );
+    this.entries = test.fn(super.entries.bind(this)).mockName(
+      "next/headers::headers().entries"
+    );
+    this.keys = test.fn(super.keys.bind(this)).mockName("next/headers::headers().keys");
+    this.values = test.fn(super.values.bind(this)).mockName(
+      "next/headers::headers().values"
+    );
+  }
+};
+var headersAdapterMock;
+var headers = () => {
+  if (!headersAdapterMock) headersAdapterMock = new HeadersAdapterMock();
+  return headersAdapterMock;
+};
+headers.mockRestore = () => {
+  headersAdapterMock = new HeadersAdapterMock();
+};
+var RequestCookiesMock = class extends index_js.RequestCookies {
+  constructor() {
+    super(...arguments);
+    this.get = test.fn(super.get.bind(this)).mockName("next/headers::cookies().get");
+    this.getAll = test.fn(super.getAll.bind(this)).mockName(
+      "next/headers::cookies().getAll"
+    );
+    this.has = test.fn(super.has.bind(this)).mockName("next/headers::cookies().has");
+    this.set = test.fn(super.set.bind(this)).mockName("next/headers::cookies().set");
+    this.delete = test.fn(super.delete.bind(this)).mockName(
+      "next/headers::cookies().delete"
+    );
+  }
+};
+var requestCookiesMock;
+var cookies = test.fn(() => {
+  if (!requestCookiesMock) {
+    requestCookiesMock = new RequestCookiesMock(headers());
+  }
+  return requestCookiesMock;
+}).mockName("next/headers::cookies()");
+var originalRestore = cookies.mockRestore.bind(null);
+cookies.mockRestore = () => {
+  originalRestore();
+  headers.mockRestore();
+  requestCookiesMock = new RequestCookiesMock(headers());
+};
+
+// src/plugins/next-mocks/alias/headers/index.ts
+var draftMode2 = test.fn(originalHeaders__namespace.draftMode).mockName("draftMode");
+
+exports.cookies = cookies;
+exports.draftMode = draftMode2;
+exports.headers = headers;

package/dist/plugins/next-mocks/alias/headers/index.d.cts

@@ -0,0 +1,11 @@
+import * as vitest from 'vitest';
+import * as next_dist_client_components_draft_mode from 'next/dist/client/components/draft-mode';
+export { headers } from './headers.cjs';
+export { cookies } from './cookies.cjs';
+import 'next/dist/server/web/spec-extension/adapters/headers.js';
+import 'next/dist/compiled/@edge-runtime/cookies';
+import 'next/dist/compiled/@edge-runtime/cookies/index.js';
+
+declare const draftMode: vitest.Mock<[], next_dist_client_components_draft_mode.DraftMode>;
+
+export { draftMode };

package/dist/plugins/next-mocks/alias/navigation/index.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+var test = require('@storybook/test');
+var actual = require('next/dist/client/components/navigation.js');
+var redirectStatusCode_js = require('next/dist/client/components/redirect-status-code.js');
+var redirect_js = require('next/dist/client/components/redirect.js');
+var previewErrors = require('storybook/internal/preview-errors');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var actual__namespace = /*#__PURE__*/_interopNamespace(actual);
+
+// src/plugins/next-mocks/alias/navigation/index.ts
+var navigationAPI;
+var createNavigation = (overrides) => {
+  const navigationActions = {
+    push: test.fn().mockName("next/navigation::useRouter().push"),
+    replace: test.fn().mockName("next/navigation::useRouter().replace"),
+    forward: test.fn().mockName("next/navigation::useRouter().forward"),
+    back: test.fn().mockName("next/navigation::useRouter().back"),
+    prefetch: test.fn().mockName("next/navigation::useRouter().prefetch"),
+    refresh: test.fn().mockName("next/navigation::useRouter().refresh")
+  };
+  if (overrides) {
+    for (const key of Object.keys(navigationActions)) {
+      if (key in overrides) {
+        navigationActions[key] = test.fn((...args) => {
+          return overrides[key](...args);
+        }).mockName(`useRouter().${key}`);
+      }
+    }
+  }
+  navigationAPI = navigationActions;
+  return navigationAPI;
+};
+var getRouter = () => {
+  if (!navigationAPI) {
+    throw new previewErrors.NextjsRouterMocksNotAvailable({
+      importType: "next/navigation"
+    });
+  }
+  return navigationAPI;
+};
+var redirect = test.fn(
+  (url, type = actual__namespace.RedirectType.push) => {
+    throw redirect_js.getRedirectError(url, type, redirectStatusCode_js.RedirectStatusCode.SeeOther);
+  }
+).mockName("next/navigation::redirect");
+var permanentRedirect = test.fn(
+  (url, type = actual__namespace.RedirectType.push) => {
+    throw redirect_js.getRedirectError(url, type, redirectStatusCode_js.RedirectStatusCode.SeeOther);
+  }
+).mockName("next/navigation::permanentRedirect");
+var useSearchParams2 = test.fn(actual__namespace.useSearchParams).mockName(
+  "next/navigation::useSearchParams"
+);
+var usePathname2 = test.fn(actual__namespace.usePathname).mockName(
+  "next/navigation::usePathname"
+);
+var useSelectedLayoutSegment2 = test.fn(
+  actual__namespace.useSelectedLayoutSegment
+).mockName("next/navigation::useSelectedLayoutSegment");
+var useSelectedLayoutSegments2 = test.fn(
+  actual__namespace.useSelectedLayoutSegments
+).mockName("next/navigation::useSelectedLayoutSegments");
+var useRouter2 = test.fn(actual__namespace.useRouter).mockName(
+  "next/navigation::useRouter"
+);
+var useServerInsertedHTML2 = test.fn(actual__namespace.useServerInsertedHTML).mockName(
+  "next/navigation::useServerInsertedHTML"
+);
+var notFound2 = test.fn(actual__namespace.notFound).mockName(
+  "next/navigation::notFound"
+);
+var useParams2 = test.fn(actual__namespace.useParams).mockName(
+  "next/navigation::useParams"
+);
+
+exports.createNavigation = createNavigation;
+exports.getRouter = getRouter;
+exports.notFound = notFound2;
+exports.permanentRedirect = permanentRedirect;
+exports.redirect = redirect;
+exports.useParams = useParams2;
+exports.usePathname = usePathname2;
+exports.useRouter = useRouter2;
+exports.useSearchParams = useSearchParams2;
+exports.useSelectedLayoutSegment = useSelectedLayoutSegment2;
+exports.useSelectedLayoutSegments = useSelectedLayoutSegments2;
+exports.useServerInsertedHTML = useServerInsertedHTML2;
+Object.keys(actual).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return actual[k]; }
+  });
+});

package/dist/plugins/next-mocks/alias/navigation/index.d.cts

@@ -0,0 +1,38 @@
+import * as react from 'react';
+import * as next_dist_shared_lib_app_router_context_shared_runtime from 'next/dist/shared/lib/app-router-context.shared-runtime';
+import { Mock } from '@storybook/test';
+import * as actual from 'next/dist/client/components/navigation.js';
+export * from 'next/dist/client/components/navigation.js';
+
+declare const createNavigation: (overrides?: Record<string, (...params: unknown[]) => unknown>) => {
+    push: Mock;
+    replace: Mock;
+    forward: Mock;
+    back: Mock;
+    prefetch: Mock;
+    refresh: Mock;
+};
+declare const getRouter: () => {
+    push: Mock;
+    replace: Mock;
+    forward: Mock;
+    back: Mock;
+    prefetch: Mock;
+    refresh: Mock;
+};
+
+declare const redirect: Mock<[url: string, type?: actual.RedirectType | undefined], never>;
+declare const permanentRedirect: Mock<[url: string, type?: actual.RedirectType | undefined], never>;
+declare const useSearchParams: Mock<[], actual.ReadonlyURLSearchParams>;
+declare const usePathname: Mock<[], string>;
+declare const useSelectedLayoutSegment: Mock<[parallelRouteKey?: string | undefined], string | null>;
+declare const useSelectedLayoutSegments: Mock<[parallelRouteKey?: string | undefined], string[]>;
+declare const useRouter: Mock<[], next_dist_shared_lib_app_router_context_shared_runtime.AppRouterInstance>;
+declare const useServerInsertedHTML: Mock<[callback: () => react.ReactNode], void>;
+declare const notFound: Mock<[], never>;
+interface Params {
+    [key: string]: string | string[];
+}
+declare const useParams: Mock<[], Params>;
+
+export { createNavigation, getRouter, notFound, permanentRedirect, redirect, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/plugins/next-mocks/alias/router/index.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var test = require('@storybook/test');
+var singletonRouter = require('next/dist/client/router.js');
+var previewErrors = require('storybook/internal/preview-errors');
+var router = require('next/dist/client/router');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var singletonRouter__namespace = /*#__PURE__*/_interopNamespace(singletonRouter);
+
+// src/plugins/next-mocks/alias/router/index.ts
+var defaultRouterState = {
+  route: "/",
+  asPath: "/",
+  basePath: "/",
+  pathname: "/",
+  query: {},
+  isFallback: false,
+  isLocaleDomain: false,
+  isReady: true,
+  isPreview: false
+};
+var routerAPI;
+var createRouter = (overrides) => {
+  const routerActions = {
+    push: test.fn((..._args) => {
+      return Promise.resolve(true);
+    }).mockName("next/router::useRouter().push"),
+    replace: test.fn((..._args) => {
+      return Promise.resolve(true);
+    }).mockName("next/router::useRouter().replace"),
+    reload: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().reload"
+    ),
+    back: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().back"
+    ),
+    forward: test.fn(() => {
+    }).mockName("next/router::useRouter().forward"),
+    prefetch: test.fn((..._args) => {
+      return Promise.resolve();
+    }).mockName("next/router::useRouter().prefetch"),
+    beforePopState: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().beforePopState"
+    )
+  };
+  const routerEvents = {
+    on: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().events.on"
+    ),
+    off: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().events.off"
+    ),
+    emit: test.fn((..._args) => {
+    }).mockName(
+      "next/router::useRouter().events.emit"
+    )
+  };
+  if (overrides) {
+    for (const key of Object.keys(routerActions)) {
+      if (key in overrides) {
+        routerActions[key] = test.fn((...args) => {
+          return overrides[key](...args);
+        }).mockName(`useRouter().${key}`);
+      }
+    }
+  }
+  if (overrides?.events) {
+    for (const key of Object.keys(routerEvents)) {
+      if (key in routerEvents) {
+        routerEvents[key] = test.fn((...args) => {
+          return overrides.events[key](...args);
+        }).mockName(`useRouter().events.${key}`);
+      }
+    }
+  }
+  routerAPI = {
+    ...defaultRouterState,
+    ...overrides,
+    ...routerActions,
+    // @ts-expect-error TODO improve typings
+    events: routerEvents
+  };
+  singletonRouter__namespace.default.router = routerAPI;
+  for (const cb of singletonRouter__namespace.default.readyCallbacks) {
+    cb();
+  }
+  singletonRouter__namespace.default.readyCallbacks = [];
+  return routerAPI;
+};
+var getRouter = () => {
+  if (!routerAPI) {
+    throw new previewErrors.NextjsRouterMocksNotAvailable({
+      importType: "next/router"
+    });
+  }
+  return routerAPI;
+};
+var router_default = singletonRouter__namespace.default;
+var useRouter2 = test.fn(singletonRouter__namespace.useRouter).mockName(
+  "next/router::useRouter"
+);
+var withRouter2 = test.fn(singletonRouter__namespace.withRouter).mockName(
+  "next/router::withRouter"
+);
+
+exports.createRouter = createRouter;
+exports.default = router_default;
+exports.getRouter = getRouter;
+exports.useRouter = useRouter2;
+exports.withRouter = withRouter2;
+Object.keys(router).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return router[k]; }
+  });
+});

package/dist/plugins/next-mocks/alias/router/index.d.cts

@@ -0,0 +1,45 @@
+import * as react from 'react';
+import * as next_dist_client_with_router from 'next/dist/client/with-router';
+import * as next_types from 'next/types';
+import { Mock } from '@storybook/test';
+import * as originalRouter from 'next/dist/client/router.js';
+import originalRouter__default from 'next/dist/client/router.js';
+export { default } from 'next/dist/client/router.js';
+import { NextRouter } from 'next/router.js';
+export * from 'next/dist/client/router';
+
+/**
+ * Creates a next/router router API mock. Used internally.
+ * @ignore
+ * @internal
+ * */
+declare const createRouter: (overrides: Partial<NextRouter>) => originalRouter.NextRouter;
+declare const getRouter: () => {
+    push: Mock;
+    replace: Mock;
+    reload: Mock;
+    back: Mock;
+    forward: Mock;
+    prefetch: Mock;
+    beforePopState: Mock;
+    events: {
+        on: Mock;
+        off: Mock;
+        emit: Mock;
+    };
+} & {
+    route: string;
+    asPath: string;
+    basePath: string;
+    pathname: string;
+    query: {};
+    isFallback: boolean;
+    isLocaleDomain: boolean;
+    isReady: boolean;
+    isPreview: boolean;
+};
+
+declare const useRouter: Mock<[], originalRouter.NextRouter>;
+declare const withRouter: Mock<[ComposedComponent: next_types.NextComponentType<next_types.NextPageContext, any, next_dist_client_with_router.WithRouterProps>], react.ComponentType<next_dist_client_with_router.ExcludeRouterProps<next_dist_client_with_router.WithRouterProps>>>;
+
+export { createRouter, getRouter, useRouter, withRouter };

package/dist/plugins/next-mocks/alias/rsc/server-only.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+// src/plugins/next-mocks/alias/rsc/server-only.ts
+var server_only_default = {};
+
+module.exports = server_only_default;

package/dist/plugins/next-mocks/alias/rsc/server-only.d.cts

@@ -0,0 +1,3 @@
+declare const _default: {};
+
+export { _default as default };