@storybook/tanstack-react 0.0.0-pr-34403-sha-53a142e3

package/dist/index.d.ts

@@ -0,0 +1,408 @@
+import { ComponentType } from 'react';
+import { PreviewAddon, InferTypes, AddonTypes } from 'storybook/internal/csf';
+import { CompatibleString, ProjectAnnotations, Args, DecoratorFunction, ArgsStoryFn, ComponentAnnotations, Renderer, StoryAnnotations } from 'storybook/internal/types';
+import { AnyRoute, FileRoutesByPath } from '@tanstack/react-router';
+import { ReactTypes, ReactPreview, ReactMeta, ReactRenderer, Meta as Meta$1, StoryObj as StoryObj$1 } from '@storybook/react';
+export * from '@storybook/react';
+import { BuilderOptions } from '@storybook/builder-vite';
+import { StorybookConfig as StorybookConfig$1 } from '@storybook/react-vite';
+import { RouteOptions } from '@tanstack/router-core';
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+@see Simplify
+*/
+interface SimplifyOptions {
+	/**
+	Do the simplification recursively.
+
+	@default false
+	*/
+	deep?: boolean;
+}
+
+// Flatten a type without worrying about the result.
+type Flatten<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Options['deep'] extends true
+	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
+	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
+
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+
+@category Object
+*/
+type Simplify<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Flatten<AnyType> extends AnyType
+	? Flatten<AnyType, Options>
+	: AnyType;
+
+/**
+Remove any index signatures from the given object type, so that only explicitly defined properties remain.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		as {} extends Record<KeyType, unknown>
+			? never // => Remove this `KeyType`.
+			: KeyType // => Keep this `KeyType` as it is.
+	]: ObjectType[KeyType];
+};
+```
+
+@example
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = RemoveIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@category Object
+*/
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};
+
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+	) extends ((mergedIntersection: infer Intersection) => void)
+		? Intersection
+		: never;
+
+type IsRoute<T> = T extends AnyRoute ? true : T extends FileRoutesByPath[keyof FileRoutesByPath] ? true : false;
+type StoryRoutePathForRoute<TRoute> = TRoute extends {
+    path: infer P;
+} ? unknown extends P ? keyof FileRoutesByPath | (string & {}) : P extends '/' ? `/${string}` : P extends string ? P | `${P}/${string}` : keyof FileRoutesByPath | (string & {}) : keyof FileRoutesByPath | (string & {});
+type StoryRoutePath<TRoute = undefined> = IsRoute<TRoute> extends true ? StoryRoutePathForRoute<TRoute> : keyof FileRoutesByPath | (string & {});
+type StoryRouteParams<TRoute> = IsRoute<TRoute> extends true ? TRoute extends {
+    types: {
+        allParams: infer P;
+    };
+} ? unknown extends P ? Record<string, string> : P : Record<string, string> : Record<string, string>;
+type StoryRouteSearch<TRoute> = IsRoute<TRoute> extends true ? TRoute extends {
+    types: {
+        fullSearchSchema: infer S;
+    };
+} ? unknown extends S ? Record<string, unknown> : S : Record<string, unknown> : 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> | AnyRoute;
+/**
+ * Extracts a single route option type directly from the route's options,
+ * avoiding indexing into deferred conditional types (which causes DTS errors).
+ */
+type RouteOption<TRoute, K extends string> = IsRoute<TRoute> extends true ? TRoute extends {
+    options: Record<K, infer V>;
+} ? V : undefined : K extends keyof RouteOptions<unknown> ? RouteOptions<unknown>[K] : undefined;
+interface RouterParameters<TRoute = undefined> {
+    /** A route object or route options to use for this story. */
+    route?: StoryRouteOptions<TRoute>;
+    /** The initial URL path to render. */
+    path?: StoryRoutePath<TRoute>;
+    /** URL params to interpolate into the path (e.g. `{ id: '42' }` for `/$id`). */
+    params?: StoryRouteParams<TRoute>;
+    /** Search/query params to append to the URL (e.g. `{ tab: 'details' }`). */
+    query?: Partial<StoryRouteSearch<TRoute>>;
+    /** Override the route's loader function. */
+    loader?: RouteOption<TRoute, 'loader'>;
+    /** Override the route's beforeLoad function. */
+    beforeLoad?: RouteOption<TRoute, 'beforeLoad'>;
+    /** Override the route's search params validation. */
+    validateSearch?: RouteOption<TRoute, 'validateSearch'>;
+    /** Override the route's loader dependencies. */
+    loaderDeps?: RouteOption<TRoute, 'loaderDeps'>;
+    /** Override the route's context. */
+    context?: Record<string, unknown>;
+}
+
+type FrameworkName = CompatibleString<'@storybook/tanstack-react'>;
+type BuilderName = CompatibleString<'@storybook/builder-vite'>;
+type FrameworkOptions = {
+    /** Builder options passed through to @storybook/builder-vite. */
+    builder?: BuilderOptions;
+};
+type StorybookConfigFramework = {
+    framework: FrameworkName | {
+        name: FrameworkName;
+        options: FrameworkOptions;
+    };
+    core?: StorybookConfig$1['core'] & {
+        builder?: BuilderName | {
+            name: BuilderName;
+            options: BuilderOptions;
+        };
+    };
+};
+/** The interface for Storybook configuration in `main.ts` files. */
+type StorybookConfig = Omit<StorybookConfig$1, keyof StorybookConfigFramework> & StorybookConfigFramework;
+interface TanStackPreviewOptions<TRoute = undefined> {
+    /** Router configuration for stories */
+    router?: RouterParameters<TRoute>;
+}
+interface TanStackParameters<TRoute = undefined> {
+    /** TanStack framework configuration (router integration). */
+    tanstack?: TanStackPreviewOptions<TRoute>;
+}
+interface TanStackTypes<TRoute = undefined> {
+    parameters: TanStackParameters<TRoute>;
+}
+
+/** Extracts and unions all args types from an array of decorators. */
+type DecoratorsArgs<TRenderer extends Renderer, Decorators> = UnionToIntersection<Decorators extends DecoratorFunction<TRenderer, infer TArgs> ? TArgs : unknown>;
+type InferCombinedTypes<T, TArgs, Decorators> = ReactTypes & T & {
+    args: Simplify<TArgs & Simplify<RemoveIndexSignature<DecoratorsArgs<ReactTypes & T, Decorators>>>>;
+};
+type Preview<TRoute extends AnyRoute | undefined = undefined> = ProjectAnnotations<ReactTypes & TanStackTypes<TRoute>>;
+declare function definePreview<TRoute extends AnyRoute | undefined = undefined, Addons extends PreviewAddon<never>[] = []>(preview: {
+    addons?: Addons;
+    route?: TRoute;
+} & ProjectAnnotations<ReactTypes & TanStackTypes<NoInfer<TRoute>> & InferTypes<Addons>>): TanStackPreview<InferTypes<Addons>, TRoute>;
+/**
+ * Metadata to configure stories for a component or a TanStack Route.
+ *
+ * When `TCmpOrArgs` is a TanStack Route, the `component` field accepts the
+ * Route object directly and TanStack parameters (params, query, loader, etc.)
+ * are inferred from the route's types.
+ */
+type Meta<TCmpOrArgs = Args> = IsRoute<TCmpOrArgs> extends true ? Omit<ComponentAnnotations<ReactRenderer, Args>, 'component'> & Partial<TanStackTypes<TCmpOrArgs>> & {
+    component?: TCmpOrArgs;
+} : Meta$1<TCmpOrArgs>;
+/**
+ * When the meta's `component` is a TanStack Route, the story inherits
+ * TanStack parameter types for type-safe params/query/loader configuration.
+ */
+type StoryObj<TMetaOrCmpOrArgs = unknown> = [TMetaOrCmpOrArgs] extends [
+    {
+        component?: infer Component;
+    }
+] ? IsRoute<Component> extends true ? StoryAnnotations<ReactRenderer, Args, Partial<Args>> & Partial<TanStackTypes<Component>> : StoryObj$1<TMetaOrCmpOrArgs> & Partial<TanStackTypes> : IsRoute<TMetaOrCmpOrArgs> extends true ? StoryAnnotations<ReactRenderer, Args, Partial<Args>> & Partial<TanStackTypes<TMetaOrCmpOrArgs>> : StoryObj$1<TMetaOrCmpOrArgs> & Partial<TanStackTypes>;
+interface TanStackPreview<T extends AddonTypes, TRoute extends AnyRoute | undefined = undefined> extends ReactPreview<TanStackTypes<TRoute> & T> {
+    type<R>(): TanStackPreview<T & R, TRoute>;
+    meta<TMetaRoute extends AnyRoute, TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & TanStackTypes<TMetaRoute> & T, any>, TMetaArgs extends Partial<TArgs & (TanStackTypes<TMetaRoute> & T)['args']>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & TanStackTypes<TMetaRoute> & T, TArgs & (TanStackTypes<TMetaRoute> & T)['args']>;
+        component?: ComponentType<TArgs>;
+        /** Provide a route to enable type-safe params/query/loader inference for this meta. */
+        route: TMetaRoute;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+    } & Omit<ComponentAnnotations<ReactTypes & TanStackTypes<TMetaRoute> & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<InferCombinedTypes<TanStackTypes<TMetaRoute> & T, TArgs, Decorators>, Omit<ComponentAnnotations<InferCombinedTypes<TanStackTypes<TMetaRoute> & T, TArgs, Decorators>>, 'args'> & {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+    meta<TMetaRoute extends AnyRoute | FileRoutesByPath[keyof FileRoutesByPath], TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & TanStackTypes<TMetaRoute> & T, any>, TMetaArgs extends Partial<TArgs & (TanStackTypes<TMetaRoute> & T)['args']>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & TanStackTypes<TMetaRoute> & T, TArgs & (TanStackTypes<TMetaRoute> & T)['args']>;
+        component: TMetaRoute;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+    } & Omit<ComponentAnnotations<ReactTypes & TanStackTypes<TMetaRoute> & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<InferCombinedTypes<TanStackTypes<TMetaRoute> & T, TArgs, Decorators>, Omit<ComponentAnnotations<InferCombinedTypes<TanStackTypes<TMetaRoute> & T, TArgs, Decorators>>, 'args'> & {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+    meta<TArgs extends Args, Decorators extends DecoratorFunction<ReactTypes & TanStackTypes<TRoute> & T, any>, TMetaArgs extends Partial<TArgs & (TanStackTypes<TRoute> & T)['args']>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & TanStackTypes<TRoute> & T, TArgs & (TanStackTypes<TRoute> & T)['args']>;
+        component?: ComponentType<TArgs>;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+    } & Omit<ComponentAnnotations<ReactTypes & TanStackTypes<TRoute> & T, TArgs>, 'decorators' | 'component' | 'args' | 'render'>): ReactMeta<InferCombinedTypes<TanStackTypes<TRoute> & T, TArgs, Decorators>, Omit<ComponentAnnotations<InferCombinedTypes<TanStackTypes<TRoute> & T, TArgs, Decorators>>, 'args'> & {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+}
+
+export { type CreateStoryRouteOptions, type FrameworkOptions, type IsRoute, type Meta, type Preview, type RouterParameters, type StoryObj, type StoryRouteFileOptions, type StoryRouteOptions, type StorybookConfig, type TanStackParameters, type TanStackPreviewOptions, type TanStackTypes, definePreview };

package/dist/index.js

@@ -0,0 +1,17 @@
+import {
+  preview_exports
+} from "./_browser-chunks/chunk-LJRZDJ5L.js";
+import "./_browser-chunks/chunk-4BE7D4DS.js";
+
+// src/index.ts
+import { __definePreview } from "@storybook/react";
+export * from "@storybook/react";
+function definePreview(preview) {
+  return __definePreview({
+    ...preview,
+    addons: [preview_exports, ...preview.addons ?? []]
+  });
+}
+export {
+  definePreview
+};

package/dist/node/index.d.ts

@@ -0,0 +1,28 @@
+import { CompatibleString } from 'storybook/internal/types';
+import { BuilderOptions } from '@storybook/builder-vite';
+import { StorybookConfig as StorybookConfig$1 } from '@storybook/react-vite';
+
+type FrameworkName = CompatibleString<'@storybook/tanstack-react'>;
+type BuilderName = CompatibleString<'@storybook/builder-vite'>;
+type FrameworkOptions = {
+    /** Builder options passed through to @storybook/builder-vite. */
+    builder?: BuilderOptions;
+};
+type StorybookConfigFramework = {
+    framework: FrameworkName | {
+        name: FrameworkName;
+        options: FrameworkOptions;
+    };
+    core?: StorybookConfig$1['core'] & {
+        builder?: BuilderName | {
+            name: BuilderName;
+            options: BuilderOptions;
+        };
+    };
+};
+/** The interface for Storybook configuration in `main.ts` files. */
+type StorybookConfig = Omit<StorybookConfig$1, keyof StorybookConfigFramework> & StorybookConfigFramework;
+
+declare function defineMain(config: StorybookConfig): StorybookConfig;
+
+export { type StorybookConfig, defineMain };

package/dist/node/index.js

@@ -0,0 +1,19 @@
+import CJS_COMPAT_NODE_URL_2tdt6g07j5u from 'node:url';
+import CJS_COMPAT_NODE_PATH_2tdt6g07j5u from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2tdt6g07j5u from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_2tdt6g07j5u.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2tdt6g07j5u.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2tdt6g07j5u.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// src/node/index.ts
+function defineMain(config) {
+  return config;
+}
+export {
+  defineMain
+};

package/dist/preset.d.ts

@@ -0,0 +1,8 @@
+import { PresetProperty } from 'storybook/internal/types';
+import { StorybookConfigVite } from '@storybook/builder-vite';
+
+declare const core: PresetProperty<'core'>;
+declare const previewAnnotations: PresetProperty<'previewAnnotations'>;
+declare const viteFinal: StorybookConfigVite['viteFinal'];
+
+export { core, previewAnnotations, viteFinal };

package/dist/preset.js

@@ -0,0 +1,74 @@
+import CJS_COMPAT_NODE_URL_2tdt6g07j5u from 'node:url';
+import CJS_COMPAT_NODE_PATH_2tdt6g07j5u from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2tdt6g07j5u from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_2tdt6g07j5u.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2tdt6g07j5u.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2tdt6g07j5u.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// src/preset.ts
+import { fileURLToPath } from "node:url";
+import { viteFinal as reactViteFinal } from "@storybook/react-vite/preset";
+var INTERCEPTED_PATTERNS = ["virtual:cloudflare", "server-entry", "worker-entry"], INTERCEPTED_MODULES = ["@tanstack/react-start", "@tanstack/start-server-core"], 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"))
+], 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");
+  }, stubPath = fileURLToPath(import.meta.resolve("./export-mocks/start.js")), routerMockPath = fileURLToPath(
+    import.meta.resolve("@storybook/tanstack-react/react-router")
+  ), plugins = [
+    ...(reactConfig.plugins ?? []).filter((p) => !isTanStackStartPlugin(p)),
+    {
+      name: "tanstack-start-plugin-remover",
+      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;
+          for (let mod of INTERCEPTED_MODULES)
+            if (id === mod || id.startsWith(`${mod}/`))
+              return stubPath;
+          for (let pattern of INTERCEPTED_PATTERNS)
+            if (id.includes(pattern))
+              return stubPath;
+          return null;
+        }
+      },
+      config() {
+        return {
+          optimizeDeps: {
+            exclude: ["@storybook/tanstack-react"]
+          }
+        };
+      }
+    }
+  ];
+  return {
+    ...reactConfig,
+    plugins
+  };
+};
+export {
+  core,
+  previewAnnotations,
+  viteFinal
+};

package/dist/preview.d.ts

@@ -0,0 +1,69 @@
+import { Decorator } from '@storybook/react';
+import { LoaderFunction, Renderer } from 'storybook/internal/types';
+import { AnyRoute, FileRoutesByPath } from '@tanstack/react-router';
+import { RouteOptions } from '@tanstack/router-core';
+
+type IsRoute<T> = T extends AnyRoute ? true : T extends FileRoutesByPath[keyof FileRoutesByPath] ? true : false;
+type StoryRoutePathForRoute<TRoute> = TRoute extends {
+    path: infer P;
+} ? unknown extends P ? keyof FileRoutesByPath | (string & {}) : P extends '/' ? `/${string}` : P extends string ? P | `${P}/${string}` : keyof FileRoutesByPath | (string & {}) : keyof FileRoutesByPath | (string & {});
+type StoryRoutePath<TRoute = undefined> = IsRoute<TRoute> extends true ? StoryRoutePathForRoute<TRoute> : keyof FileRoutesByPath | (string & {});
+type StoryRouteParams<TRoute> = IsRoute<TRoute> extends true ? TRoute extends {
+    types: {
+        allParams: infer P;
+    };
+} ? unknown extends P ? Record<string, string> : P : Record<string, string> : Record<string, string>;
+type StoryRouteSearch<TRoute> = IsRoute<TRoute> extends true ? TRoute extends {
+    types: {
+        fullSearchSchema: infer S;
+    };
+} ? unknown extends S ? Record<string, unknown> : S : Record<string, unknown> : 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> | AnyRoute;
+/**
+ * Extracts a single route option type directly from the route's options,
+ * avoiding indexing into deferred conditional types (which causes DTS errors).
+ */
+type RouteOption<TRoute, K extends string> = IsRoute<TRoute> extends true ? TRoute extends {
+    options: Record<K, infer V>;
+} ? V : undefined : K extends keyof RouteOptions<unknown> ? RouteOptions<unknown>[K] : undefined;
+interface RouterParameters<TRoute = undefined> {
+    /** A route object or route options to use for this story. */
+    route?: StoryRouteOptions<TRoute>;
+    /** The initial URL path to render. */
+    path?: StoryRoutePath<TRoute>;
+    /** URL params to interpolate into the path (e.g. `{ id: '42' }` for `/$id`). */
+    params?: StoryRouteParams<TRoute>;
+    /** Search/query params to append to the URL (e.g. `{ tab: 'details' }`). */
+    query?: Partial<StoryRouteSearch<TRoute>>;
+    /** Override the route's loader function. */
+    loader?: RouteOption<TRoute, 'loader'>;
+    /** Override the route's beforeLoad function. */
+    beforeLoad?: RouteOption<TRoute, 'beforeLoad'>;
+    /** Override the route's search params validation. */
+    validateSearch?: RouteOption<TRoute, 'validateSearch'>;
+    /** Override the route's loader dependencies. */
+    loaderDeps?: RouteOption<TRoute, 'loaderDeps'>;
+    /** Override the route's context. */
+    context?: Record<string, unknown>;
+}
+
+interface TanStackPreviewOptions<TRoute = undefined> {
+    /** Router configuration for stories */
+    router?: RouterParameters<TRoute>;
+}
+interface TanStackParameters<TRoute = undefined> {
+    /** TanStack framework configuration (router integration). */
+    tanstack?: TanStackPreviewOptions<TRoute>;
+}
+
+declare const loaders: LoaderFunction<Renderer>[];
+declare const decorators: Decorator[];
+declare const parameters: TanStackParameters;
+
+export { decorators, loaders, parameters };

package/dist/preview.js

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