@storybook/tanstack-react 0.0.0 → 10.4.0-alpha.18

package/dist/preset.js

@@ -0,0 +1,403 @@
+import CJS_COMPAT_NODE_URL_846xwv5762j from 'node:url';
+import CJS_COMPAT_NODE_PATH_846xwv5762j from 'node:path';
+import CJS_COMPAT_NODE_MODULE_846xwv5762j from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_846xwv5762j.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_846xwv5762j.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_846xwv5762j.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// src/preset.ts
+import { fileURLToPath } from "node:url";
+
+// ../../../node_modules/pathe/dist/shared/pathe.ff20891b.mjs
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var dirname = function(p) {
+  let segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+// src/preset.ts
+import { viteFinal as reactViteFinal } from "@storybook/react-vite/preset";
+
+// src/plugins/server-code-elimination.ts
+import { transformSync, types as t } from "storybook/internal/babel";
+var SERVER_FN_RE = /\bcreateServerFn\b/, MIDDLEWARE_RE = /\bcreateMiddleware\b/, ISOMORPHIC_FN_RE = /\bcreateIsomorphicFn\b/, SERVER_ONLY_FN_RE = /\bcreateServerOnlyFn\b/, CLIENT_ONLY_FN_RE = /\bcreateClientOnlyFn\b/, ROUTE_FACTORY_RE = /\b(createFileRoute|createRootRoute|createRootRouteWithContext|createRoute)\b/, ROUTE_FACTORIES = /* @__PURE__ */ new Set([
+  "createFileRoute",
+  "createRootRoute",
+  "createRootRouteWithContext",
+  "createRoute"
+]), ANY_PATTERN_RE = /\b(createServerFn|createMiddleware|createIsomorphicFn|createServerOnlyFn|createClientOnlyFn|createFileRoute|createRootRoute|createRootRouteWithContext|createRoute)\b/;
+function serverCodeEliminationPlugin(options = {}) {
+  let excludeFiles = options.excludeFiles ?? [];
+  return {
+    name: "storybook:tanstack-react:server-code-elimination",
+    enforce: "pre",
+    transform: {
+      // we can fully rely on transform.filter
+      // and not worry about the handler since tanstack start users are Vite > 8 only
+      filter: {
+        id: {
+          include: [/\.tsx?$/],
+          exclude: [/node_modules/]
+        },
+        code: ANY_PATTERN_RE
+      },
+      async handler(code, id) {
+        if (!/\.[mc]?[jt]sx?$/.test(id) || excludeFiles.some((excluded) => id.includes(excluded)) || !ANY_PATTERN_RE.test(code))
+          return null;
+        let state = { code, modified: !1, needsFnImport: !1 }, result = transformSync(code, {
+          filename: id,
+          sourceType: "module",
+          parserOpts: {
+            plugins: ["typescript", "jsx"]
+          },
+          plugins: [() => serverCodeElimination(state)],
+          sourceMaps: !0,
+          configFile: !1,
+          babelrc: !1
+        });
+        return !state.modified || !result?.code ? null : {
+          code: result.code,
+          map: result.map
+        };
+      }
+    }
+  };
+}
+function serverCodeElimination(state) {
+  function sbFnCall() {
+    return state.needsFnImport = !0, buildFnCall();
+  }
+  function sbFnCallWithImpl(impl) {
+    return state.needsFnImport = !0, buildFnCallWithImpl(impl);
+  }
+  return {
+    visitor: {
+      Program(programPath) {
+        let tanstackImports = collectTanstackImports(programPath.node.body), resolves = (name, factory) => resolvesToFactory(tanstackImports, name, factory);
+        programPath.traverse({
+          CallExpression(path2) {
+            let node = path2.node;
+            if (ROUTE_FACTORY_RE.test(state.code)) {
+              let routeOptionsArg = getRouteFactoryOptionsArg(node, tanstackImports);
+              routeOptionsArg && stripServerOption(routeOptionsArg) && (state.modified = !0);
+            }
+            if (t.isIdentifier(node.callee) && resolves(node.callee.name, "createServerOnlyFn") && SERVER_ONLY_FN_RE.test(state.code)) {
+              path2.replaceWith(sbFnCall()), state.modified = !0;
+              return;
+            }
+            if (t.isIdentifier(node.callee) && resolves(node.callee.name, "createClientOnlyFn") && CLIENT_ONLY_FN_RE.test(state.code)) {
+              let innerFn = node.arguments[0];
+              innerFn && t.isExpression(innerFn) && (path2.replaceWith(sbFnCallWithImpl(innerFn)), state.modified = !0);
+              return;
+            }
+            let methodName = getMethodName(node);
+            if (!methodName)
+              return;
+            let root = findChainRoot(node);
+            if (root) {
+              if (methodName === "handler" && resolves(root.rootName, "createServerFn") && SERVER_FN_RE.test(state.code)) {
+                let handlerArg = node.arguments[0];
+                if (handlerArg) {
+                  if (t.isIdentifier(handlerArg)) {
+                    let binding = path2.scope.getBinding(handlerArg.name);
+                    binding && binding.referencePaths.length === 1 && binding.path.remove();
+                  }
+                  node.arguments[0] = sbFnCall();
+                }
+                state.modified = !0;
+                return;
+              }
+              if (resolves(root.rootName, "createMiddleware") && MIDDLEWARE_RE.test(state.code)) {
+                (methodName === "server" || methodName === "inputValidator") && t.isMemberExpression(path2.node.callee) && (path2.replaceWith(path2.node.callee.object), state.modified = !0);
+                return;
+              }
+              if (resolves(root.rootName, "createIsomorphicFn") && ISOMORPHIC_FN_RE.test(state.code)) {
+                if (methodName === "client") {
+                  let innerFn = node.arguments[0];
+                  innerFn && t.isExpression(innerFn) && (path2.replaceWith(sbFnCallWithImpl(innerFn)), state.modified = !0);
+                  return;
+                }
+                if (methodName === "server") {
+                  let parent = path2.parent;
+                  (!t.isMemberExpression(parent) || !t.isCallExpression(path2.parentPath?.parent)) && (path2.replaceWith(sbFnCall()), state.modified = !0);
+                }
+                return;
+              }
+            }
+          }
+        }), state.modified && (state.needsFnImport && programPath.node.body.unshift(buildFnImport()), eliminateDeadImports(programPath));
+      }
+    }
+  };
+}
+function buildFnImport() {
+  return t.importDeclaration(
+    [t.importSpecifier(t.identifier("__sb_fn"), t.identifier("fn"))],
+    t.stringLiteral("storybook/test")
+  );
+}
+function buildFnCall() {
+  return t.callExpression(t.identifier("__sb_fn"), []);
+}
+function buildFnCallWithImpl(impl) {
+  return t.callExpression(t.identifier("__sb_fn"), [impl]);
+}
+function collectTanstackImports(body) {
+  let imports = /* @__PURE__ */ new Map();
+  for (let node of body) {
+    if (!t.isImportDeclaration(node))
+      continue;
+    let src = node.source.value;
+    if (!(!src.includes("@tanstack/") && !src.includes("export-mocks") && !src.includes("@storybook/tanstack-react"))) {
+      for (let spec of node.specifiers)
+        if (t.isImportSpecifier(spec)) {
+          let importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          imports.set(spec.local.name, importedName);
+        }
+    }
+  }
+  return imports;
+}
+function resolvesToFactory(imports, name, factoryName) {
+  return name === factoryName || imports.get(name) === factoryName;
+}
+function findChainRoot(node) {
+  let current = node;
+  for (; ; ) {
+    let callee = current.callee;
+    if (t.isIdentifier(callee))
+      return { rootCall: current, rootName: callee.name };
+    if (t.isMemberExpression(callee) && t.isCallExpression(callee.object)) {
+      current = callee.object;
+      continue;
+    }
+    return null;
+  }
+}
+function getMethodName(node) {
+  return t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property) ? node.callee.property.name : null;
+}
+function getRouteFactoryOptionsArg(node, imports) {
+  if (!getRouteFactoryName(node, imports))
+    return null;
+  let optionsArg = node.arguments[0];
+  return t.isObjectExpression(optionsArg) ? optionsArg : null;
+}
+function getRouteFactoryName(node, imports) {
+  if (t.isIdentifier(node.callee)) {
+    let resolved = imports.get(node.callee.name) ?? node.callee.name;
+    return ROUTE_FACTORIES.has(resolved) ? resolved : null;
+  }
+  if (t.isCallExpression(node.callee) && t.isIdentifier(node.callee.callee)) {
+    let calleeName = node.callee.callee.name, resolved = imports.get(calleeName) ?? calleeName;
+    return ROUTE_FACTORIES.has(resolved) ? resolved : null;
+  }
+  return null;
+}
+function stripServerOption(options) {
+  let initialLength = options.properties.length;
+  return options.properties = options.properties.filter((prop) => {
+    if (!t.isObjectProperty(prop) || prop.computed)
+      return !0;
+    let key = prop.key;
+    return (t.isIdentifier(key) ? key.name : void 0) !== "server";
+  }), options.properties.length !== initialLength;
+}
+function eliminateDeadImports(programPath) {
+  let referencedIdentifiers = /* @__PURE__ */ new Set();
+  programPath.traverse({
+    enter(path2) {
+      let { node } = path2;
+      !t.isIdentifier(node) || path2.isBindingIdentifier() || path2.findParent((p) => p.isImportDeclaration()) || referencedIdentifiers.add(node.name);
+    }
+  }), programPath.traverse({
+    ImportDeclaration(path2) {
+      let specifiers = path2.node.specifiers.filter(
+        (spec) => referencedIdentifiers.has(spec.local.name)
+      );
+      specifiers.length === 0 ? path2.remove() : specifiers.length !== path2.node.specifiers.length && (path2.node.specifiers = specifiers);
+    }
+  });
+}
+
+// src/plugins/server-only-stub.ts
+import { babelParse as parse2, types as t2 } from "storybook/internal/babel";
+var SERVER_FILE_RE = /\.server\.(?:[mc]?[jt]sx?)$/;
+function serverOnlyStubPlugin(options = {}) {
+  let patterns = [SERVER_FILE_RE, ...options.extraPatterns ?? []];
+  return {
+    name: "storybook:tanstack-react:server-only-stub",
+    enforce: "pre",
+    transform: {
+      filter: {
+        id: {
+          // The `id` filter is matched against the full resolved id, so the
+          // pattern matches both `src/utils/foo.server.ts` and any other
+          // `.server.*` file. We additionally re-check inside the handler in
+          // case Vite ever changes how filters are applied.
+          include: patterns,
+          exclude: [/node_modules/]
+        }
+      },
+      handler(code, id) {
+        if (!patterns.some((re) => re.test(id)))
+          return null;
+        let exports = collectExports(code, id);
+        return {
+          code: buildStubCode(exports, id),
+          map: { mappings: "" }
+        };
+      }
+    }
+  };
+}
+function collectExports(code, id) {
+  let named = /* @__PURE__ */ new Set(), hasDefault = !1, ast;
+  try {
+    ast = parse2(code);
+  } catch {
+    return { named, hasDefault };
+  }
+  for (let node of ast.program.body) {
+    if (t2.isExportDefaultDeclaration(node)) {
+      hasDefault = !0;
+      continue;
+    }
+    if (!t2.isExportAllDeclaration(node) && t2.isExportNamedDeclaration(node)) {
+      let decl = node.declaration;
+      if (decl)
+        if (t2.isVariableDeclaration(decl))
+          for (let declarator of decl.declarations)
+            t2.isIdentifier(declarator.id) && named.add(declarator.id.name);
+        else (t2.isFunctionDeclaration(decl) || t2.isClassDeclaration(decl)) && decl.id?.name && named.add(decl.id.name);
+      for (let spec of node.specifiers)
+        if (t2.isExportSpecifier(spec)) {
+          let exportedName = t2.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+          exportedName !== "default" ? named.add(exportedName) : hasDefault = !0;
+        }
+    }
+  }
+  return { named, hasDefault };
+}
+function buildStubCode(exports, id) {
+  let label = JSON.stringify(id), namedExports = [...exports.named].map((name) => `export const ${name} = __sb_serverOnly(${JSON.stringify(name)});`).join(`
+`), defaultExport = exports.hasDefault ? "export default __sb_serverOnly('default');" : "";
+  return `import { fn as __sb_fn } from 'storybook/test';
+function __sb_serverOnly(name) {
+  return __sb_fn(() => {
+    throw new Error(
+      \`[storybook] Tried to call server-only export "\${name}" from \${${label}} in the browser.\`
+    );
+  }).mockName(name);
+}
+${namedExports}
+${defaultExport}`.trim();
+}
+
+// src/plugins/module-interception.ts
+var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"], START_SERVER_MODULES = [
+  "@tanstack/react-start",
+  "@tanstack/react-start/server",
+  "@tanstack/react-start-server",
+  "@tanstack/start-server-core"
+];
+function moduleInterceptionPlugin({
+  startMockPath,
+  startStorageContextMockPath,
+  routerMockPath
+}) {
+  return {
+    name: "storybook:tanstack-react:module-interception",
+    enforce: "pre",
+    resolveId: {
+      order: "pre",
+      handler(id, importer) {
+        if ((id === "@tanstack/react-router" || id.startsWith("@tanstack/react-router/")) && importer && !importer.includes("export-mocks"))
+          return routerMockPath;
+        if (START_SERVER_MODULES.includes(id) || id === "@tanstack/react-start")
+          return startMockPath;
+        if (id === "@tanstack/start-storage-context")
+          return startStorageContextMockPath;
+        for (let pattern of INTERCEPTED_PATTERNS)
+          if (id.includes(pattern))
+            return startMockPath;
+        return null;
+      }
+    },
+    config() {
+      return {
+        optimizeDeps: {
+          exclude: [
+            "@storybook/react",
+            "@storybook/react/entry-preview",
+            "@storybook/react/entry-preview-argtypes",
+            "@storybook/react/entry-preview-docs",
+            "@storybook/tanstack-react",
+            "@tanstack/react-start",
+            "@tanstack/react-start/server",
+            "@tanstack/react-start-server",
+            "@tanstack/start-server-core"
+          ]
+        }
+      };
+    }
+  };
+}
+
+// src/preset.ts
+var core = async (config, options) => {
+  let framework = await options.presets.apply("framework");
+  return {
+    ...config,
+    builder: {
+      name: fileURLToPath(import.meta.resolve("@storybook/builder-vite")),
+      options: typeof framework == "string" ? {} : framework.options.builder || {}
+    },
+    renderer: fileURLToPath(import.meta.resolve("@storybook/react/preset"))
+  };
+}, previewAnnotations = (entry = []) => [
+  ...entry,
+  fileURLToPath(import.meta.resolve("@storybook/tanstack-react/preview"))
+], optimizeViteDeps = [
+  "@tanstack/react-store",
+  "@tanstack/react-router > @tanstack/react-store",
+  "use-sync-external-store/shim/with-selector"
+], viteFinal = async (config, options) => {
+  let reactConfig = await reactViteFinal(config, options), isTanStackStartPlugin = (p) => {
+    if (Array.isArray(p))
+      return p.some(isTanStackStartPlugin);
+    let pluginRecord = p;
+    return typeof p == "object" && p !== null && "name" in pluginRecord && typeof pluginRecord.name == "string" && (pluginRecord.name.startsWith("tanstack-start") || pluginRecord.name.includes("rsc:"));
+  }, startMockPath = fileURLToPath(import.meta.resolve("./export-mocks/start.js")), startStorageContextMockPath = fileURLToPath(
+    import.meta.resolve("./export-mocks/start-storage-context.js")
+  ), routerMockPath = fileURLToPath(
+    import.meta.resolve("@storybook/tanstack-react/react-router")
+  ), plugins = [
+    ...(reactConfig.plugins ?? []).filter((p) => !isTanStackStartPlugin(p)),
+    serverCodeEliminationPlugin({ excludeFiles: [dirname(startMockPath)] }),
+    serverOnlyStubPlugin(),
+    moduleInterceptionPlugin({ startMockPath, startStorageContextMockPath, routerMockPath })
+  ];
+  return {
+    ...reactConfig,
+    plugins
+  };
+};
+export {
+  core,
+  optimizeViteDeps,
+  previewAnnotations,
+  viteFinal
+};

package/dist/preview.d.ts

@@ -0,0 +1,111 @@
+import { LoaderFunction, Renderer, DecoratorFunction } from 'storybook/internal/types';
+import { applyDecorators as applyDecorators$1 } from '@storybook/react/entry-preview-docs';
+import { Register, AnyRoute, FileRoutesByPath } from '@tanstack/react-router';
+import { RoutesByPath, RouteOptions, ResolveParams, AnyContext } from '@tanstack/router-core';
+import { Decorator } from '@storybook/react';
+
+/** Union of every registered full path (e.g. `'/' | '/admin/users' | '/$libraryId/$version'`). */
+type RegisteredFullPath = keyof Register['router']['routesByPath'];
+type IsAppRouteTree<TRoute> = TRoute extends Register['router']['routeTree'] ? true : false;
+type IsRoute<T> = T extends AnyRoute ? true : T extends FileRoutesByPath[keyof FileRoutesByPath] ? true : false;
+type ExtractAllPathsFromFileRoutes<TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] | AnyRoute> = TRoute['path'];
+type StoryRoutePath<TRoute = undefined> = TRoute extends FileRoutesByPath[keyof FileRoutesByPath] ? ExtractAllPathsFromFileRoutes<TRoute> : keyof FileRoutesByPath | `/${string}`;
+type StoryRouteSearch<TRoute> = IsAppRouteTree<TRoute> extends true ? Record<string, unknown> : TRoute extends FileRoutesByPath[keyof FileRoutesByPath] ? TRoute['preLoaderRoute'] extends {
+    types: {
+        allSearch: infer A;
+    };
+} ? A : never : Record<string, unknown>;
+type StoryRouteFileOptions<TRoute = undefined> = IsRoute<TRoute> extends true ? TRoute extends {
+    options: infer O;
+} ? Pick<O, Extract<keyof O, 'loader' | 'beforeLoad' | 'validateSearch' | 'loaderDeps' | 'context' | 'params' | 'head' | 'search' | 'parseParams' | 'context'>> : Pick<RouteOptions<unknown>, 'loader' | 'beforeLoad' | 'validateSearch' | 'loaderDeps' | 'context' | 'params' | 'head' | 'search' | 'parseParams' | 'context'> : Pick<RouteOptions<unknown>, 'loader' | 'beforeLoad' | 'validateSearch' | 'loaderDeps' | 'context' | 'params' | 'head' | 'search' | 'parseParams' | 'context'>;
+type CreateStoryRouteOptions<TRoute = undefined> = StoryRouteFileOptions<TRoute> & {
+    path?: StoryRoutePath<TRoute>;
+};
+type StoryRouteOptions<TRoute = undefined> = CreateStoryRouteOptions<TRoute> | (TRoute extends AnyRoute ? TRoute : AnyRoute);
+/**
+ * Per-route override options for use inside `RouteTreeOverrides`.
+ * Users can override `loader`, `beforeLoad`, etc. for a specific route.
+ */
+interface RouteOverrideOptions<TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] | undefined = undefined> {
+    /** Override the route's loader function. */
+    loader?: TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] ? TRoute['options']['loader'] | ((ctx: unknown) => Promise<unknown> | unknown) : (ctx: unknown) => Promise<unknown> | unknown;
+    /** Override the route's beforeLoad function. */
+    beforeLoad?: TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] ? TRoute['options']['beforeLoad'] | ((ctx: unknown) => Promise<void> | void) : (ctx: unknown) => Promise<void> | void;
+    /** Override the route's search params validation. */
+    validateSearch?: TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] ? TRoute['options']['validateSearch'] | ((search: unknown) => Promise<void> | void) : (search: unknown) => Promise<void> | void;
+    /** Override the route's loader dependencies. */
+    loaderDeps?: TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] ? TRoute['options']['loaderDeps'] | string[] : string[];
+    /** Override the route's context function. */
+    context?: TRoute extends FileRoutesByPath[keyof FileRoutesByPath]['preLoaderRoute'] ? TRoute['options']['context'] | ((ctx: unknown) => Promise<unknown> | unknown) : (ctx: unknown) => Promise<unknown> | unknown;
+}
+/**
+ * A map of route overrides keyed by route ID.
+ * Each entry can override `loader`, `beforeLoad`, etc. for that route.
+ *
+ * @example
+ * ```ts
+ * routeOverrides: {
+ *   '/_authed': { beforeLoad: () => {} },
+ *   '/demo/form/simple/$id': {
+ *     loader: async () => ({ name: 'Mock User' }),
+ *   },
+ * }
+ * ```
+ */
+type RouteTreeOverrides = Partial<{
+    [routePath in keyof FileRoutesByPath]: RouteOverrideOptions<FileRoutesByPath[routePath]['preLoaderRoute']> | undefined;
+}>;
+interface RouterParameters<TRoute = undefined, Path extends TRoute extends AnyRoute ? keyof RoutesByPath<TRoute> : RegisteredFullPath = TRoute extends AnyRoute ? keyof RoutesByPath<TRoute> : keyof FileRoutesByPath> {
+    route?: StoryRouteOptions<TRoute>;
+    /**
+     * Path to resolve the story route against.
+     * Constrained to known registered paths in route tree mode, but can be any string in app route mode (since the user may be passing a custom `route` that doesn't exist in the registered tree).
+     */
+    path?: Path;
+    /** URL params to interpolate into the path (e.g. `{ id: '42' }` for `/$id`). */
+    params?: ResolveParams<Path>;
+    /** Search/query params to append to the URL (e.g. `{ tab: 'details' }`). */
+    query?: Partial<StoryRouteSearch<TRoute>>;
+    /**
+     * Override options for specific routes in the app route tree (route tree mode only).
+     *
+     * Each key is a route ID (e.g. `'/about'`, `'__root__'`, `'/demo/form/simple/$id'`).
+     * Values can override `loader`, `beforeLoad`, etc. for that route.
+     *
+     * @example
+     * ```ts
+     * routeOverrides: {
+     *   '/_authed': { beforeLoad: () => {} },
+     *   '/demo/form/simple/$id': {
+     *     loader: async () => ({ name: 'Mock User' }),
+     *   },
+     * }
+     * ```
+     */
+    routeOverrides?: RouteTreeOverrides;
+    context?: Record<string, unknown>;
+    /**
+     *
+     */
+    useRouterContext?: ({ storyContext }: {
+        storyContext: Parameters<Decorator>[1];
+    }) => AnyContext;
+}
+
+/** Path constraint mirroring `RouterParameters`'s second generic. */
+type DefaultStoryPath<TRoute> = TRoute extends AnyRoute ? keyof RoutesByPath<TRoute> : RegisteredFullPath;
+interface TanStackPreviewOptions<TRoute = undefined, Path extends DefaultStoryPath<TRoute> = DefaultStoryPath<TRoute>> {
+    /** Router configuration for stories */
+    router?: RouterParameters<TRoute, Path>;
+}
+interface TanStackParameters<TRoute = undefined, Path extends DefaultStoryPath<TRoute> = DefaultStoryPath<TRoute>> {
+    /** TanStack framework configuration (router integration). */
+    tanstack?: TanStackPreviewOptions<TRoute, Path>;
+}
+
+declare const loaders: LoaderFunction<Renderer>[];
+declare const applyDecorators: (storyFn: Parameters<typeof applyDecorators$1>[0], allDecorators: DecoratorFunction[]) => any;
+declare const parameters: TanStackParameters;
+declare const optimizeDeps: string[];
+
+export { applyDecorators, loaders, optimizeDeps, parameters };

package/dist/preview.js

@@ -0,0 +1,13 @@
+import {
+  applyDecorators,
+  loaders,
+  optimizeDeps,
+  parameters
+} from "./_browser-chunks/chunk-73EPJ7AY.js";
+import "./_browser-chunks/chunk-4BE7D4DS.js";
+export {
+  applyDecorators,
+  loaders,
+  optimizeDeps,
+  parameters
+};

package/package.json

@@ -1,9 +1,112 @@
 {
   "name": "@storybook/tanstack-react",
-  "version": "0.0.0",
-  "description": "",
-  "keywords": [],
+  "version": "10.4.0-alpha.18",
+  "description": "Storybook for TanStack (React, Vite): Router and Start ready Storybook framework",
+  "keywords": [
+    "storybook",
+    "storybook-framework",
+    "tanstack",
+    "tanstack-router",
+    "tanstack-start",
+    "react",
+    "vite",
+    "component",
+    "components"
+  ],
+  "homepage": "https://github.com/storybookjs/storybook/tree/next/code/frameworks/tanstack-react",
+  "bugs": {
+    "url": "https://github.com/storybookjs/storybook/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/storybookjs/storybook.git",
+    "directory": "code/frameworks/tanstack-react"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/storybook"
+  },
   "license": "MIT",
-  "access": "public",
-  "author": ""
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "code": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "code": "./src/node/index.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./package.json": "./package.json",
+    "./preset": {
+      "types": "./dist/preset.d.ts",
+      "code": "./src/preset.ts",
+      "default": "./dist/preset.js"
+    },
+    "./preview": {
+      "types": "./dist/preview.d.ts",
+      "code": "./src/preview.tsx",
+      "default": "./dist/preview.js"
+    },
+    "./react-router": {
+      "types": "./dist/export-mocks/react-router.d.ts",
+      "code": "./src/export-mocks/react-router.ts",
+      "default": "./dist/export-mocks/react-router.js"
+    },
+    "./start": {
+      "types": "./dist/export-mocks/start.d.ts",
+      "code": "./src/export-mocks/start.ts",
+      "default": "./dist/export-mocks/start.js"
+    },
+    "./start-storage-context": {
+      "types": "./dist/export-mocks/start-storage-context.d.ts",
+      "code": "./src/export-mocks/start-storage-context.ts",
+      "default": "./dist/export-mocks/start-storage-context.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "template/**/*",
+    "README.md",
+    "*.js",
+    "*.d.ts",
+    "!src/**/*"
+  ],
+  "dependencies": {
+    "@storybook/builder-vite": "10.4.0-alpha.18",
+    "@storybook/react": "10.4.0-alpha.18",
+    "@storybook/react-vite": "10.4.0-alpha.18"
+  },
+  "devDependencies": {
+    "@tanstack/react-router": "^1.168.10",
+    "@tanstack/react-start": "^1.167.16",
+    "@tanstack/router-core": "^1.168.9",
+    "@tanstack/start-client-core": "^1.167.9",
+    "@types/node": "^22.19.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.0.4"
+  },
+  "peerDependencies": {
+    "@tanstack/react-router": "^1.168.10",
+    "@tanstack/react-start": "^1.167.16",
+    "@tanstack/router-core": "^1.168.9",
+    "@tanstack/start-client-core": "^1.167.9",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+    "storybook": "^10.4.0-alpha.18",
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-start": {
+      "optional": true
+    },
+    "@tanstack/start-client-core": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }