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

package/dist/index.d.ts

@@ -0,0 +1,438 @@
+import { ComponentType } from 'react';
+import { PreviewAddon, InferTypes, AddonTypes } from 'storybook/internal/csf';
+import { CompatibleString, ProjectAnnotations, Args, DecoratorFunction, ArgsStoryFn, Parameters as Parameters$1, ComponentAnnotations, Renderer, StoryAnnotations } from 'storybook/internal/types';
+import { Register, AnyRoute, FileRoutesByPath } from '@tanstack/react-router';
+import { Decorator, ReactTypes, ReactPreview, ReactMeta, ReactRenderer, Meta as Meta$1, StoryObj as StoryObj$1 } from '@storybook/react';
+export * from '@storybook/react';
+import { RoutesByPath, RouteOptions, ResolveParams, AnyContext } from '@tanstack/router-core';
+import { BuilderOptions } from '@storybook/builder-vite';
+import { StorybookConfig as StorybookConfig$1 } from '@storybook/react-vite';
+
+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;
+
+/** 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;
+}
+
+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;
+/** 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>;
+}
+interface TanStackTypes<TRoute = undefined, Path extends DefaultStoryPath<TRoute> = DefaultStoryPath<TRoute>> {
+    parameters: TanStackParameters<TRoute, Path>;
+}
+
+/** 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, const TPath extends DefaultStoryPath<TRoute> = DefaultStoryPath<TRoute>, Addons extends PreviewAddon<never>[] = []>(preview: {
+    addons?: Addons;
+    route?: TRoute;
+} & ProjectAnnotations<ReactTypes & TanStackTypes<NoInfer<TRoute>, TPath> & 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>> : 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, const TPath extends DefaultStoryPath<TMetaRoute> = DefaultStoryPath<TMetaRoute>, TArgs extends Args = Args, Decorators extends DecoratorFunction<ReactTypes & TanStackTypes<TMetaRoute, TPath> & T, any> = DecoratorFunction<ReactTypes & TanStackTypes<TMetaRoute, TPath> & T, any>, TMetaArgs extends Partial<TArgs & (TanStackTypes<TMetaRoute, TPath> & T)['args']> = Partial<TArgs & (TanStackTypes<TMetaRoute, TPath> & T)['args']>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & TanStackTypes<TMetaRoute, TPath> & T, TArgs & (TanStackTypes<TMetaRoute, TPath> & T)['args']>;
+        component?: ComponentType<TArgs>;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+        parameters?: TanStackParameters<TMetaRoute, TPath> & Parameters$1 & (ReactTypes & T)['parameters'];
+    } & Omit<ComponentAnnotations<ReactTypes & TanStackTypes<TMetaRoute, TPath> & T, TArgs>, 'decorators' | 'component' | 'args' | 'render' | 'parameters'>): ReactMeta<InferCombinedTypes<TanStackTypes<TMetaRoute, TPath> & T, TArgs, Decorators>, Omit<ComponentAnnotations<InferCombinedTypes<TanStackTypes<TMetaRoute, TPath> & T, TArgs, Decorators>>, 'args'> & {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+    meta<const TPath extends DefaultStoryPath<TRoute> = DefaultStoryPath<TRoute>, TArgs extends Args = Args, Decorators extends DecoratorFunction<ReactTypes & TanStackTypes<TRoute, TPath> & T, any> = DecoratorFunction<ReactTypes & TanStackTypes<TRoute, TPath> & T, any>, TMetaArgs extends Partial<TArgs & (TanStackTypes<TRoute, TPath> & T)['args']> = Partial<TArgs & (TanStackTypes<TRoute, TPath> & T)['args']>>(meta: {
+        render?: ArgsStoryFn<ReactTypes & TanStackTypes<TRoute, TPath> & T, TArgs & (TanStackTypes<TRoute, TPath> & T)['args']>;
+        component?: ComponentType<TArgs>;
+        decorators?: Decorators | Decorators[];
+        args?: TMetaArgs;
+        parameters?: TanStackParameters<TRoute, TPath> & Parameters$1 & (ReactTypes & T)['parameters'];
+    } & Omit<ComponentAnnotations<ReactTypes & TanStackTypes<TRoute, TPath> & T, TArgs>, 'decorators' | 'component' | 'args' | 'render' | 'parameters'>): ReactMeta<InferCombinedTypes<TanStackTypes<TRoute, TPath> & T, TArgs, Decorators>, Omit<ComponentAnnotations<InferCombinedTypes<TanStackTypes<TRoute, TPath> & T, TArgs, Decorators>>, 'args'> & {
+        args: Partial<TArgs> extends TMetaArgs ? {} : TMetaArgs;
+    }>;
+}
+
+export { type CreateStoryRouteOptions, type DefaultStoryPath, 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-73EPJ7AY.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_fmhd7e5wemi from 'node:url';
+import CJS_COMPAT_NODE_PATH_fmhd7e5wemi from 'node:path';
+import CJS_COMPAT_NODE_MODULE_fmhd7e5wemi from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_fmhd7e5wemi.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_fmhd7e5wemi.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_fmhd7e5wemi.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 };