@storybook/web-components 10.6.0-alpha.0 → 10.6.0-alpha.2

package/dist/index.d.ts

@@ -1,46 +1,48 @@
-import { WebRenderer, Args, ComponentAnnotations, AnnotatedStoryFn, StoryAnnotations, StrictArgs, DecoratorFunction, LoaderFunction, StoryContext as StoryContext$1, ProjectAnnotations, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations, Renderer, ArgsStoryFn } from 'storybook/internal/types';
-export { ArgTypes, Args, Parameters, StrictArgs } from 'storybook/internal/types';
-import { TemplateResult, SVGTemplateResult } from 'lit';
-import { PreviewAddon, InferTypes, AddonTypes, Preview as Preview$1, Meta as Meta$1, Story } from 'storybook/internal/csf';
+import { AnnotatedStoryFn, ArgTypes, Args, Args as Args$1, ArgsStoryFn, ComponentAnnotations, DecoratorFunction, LoaderFunction, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations, Parameters as Parameters$1, ProjectAnnotations, Renderer, StoryAnnotations, StoryContext as StoryContext$1, StrictArgs, StrictArgs as StrictArgs$1, WebRenderer } from "storybook/internal/types";
+import { SVGTemplateResult, TemplateResult } from "lit";
+import { AddonTypes, InferTypes, Meta as Meta$1, Preview as Preview$1, PreviewAddon, Story } from "storybook/internal/csf";
 
+//#region code/renderers/web-components/.dts-emit/code/renderers/web-components/src/types.d.ts
 type StoryFnHtmlReturnType = string | Node | DocumentFragment | TemplateResult | SVGTemplateResult;
 interface WebComponentsRenderer extends WebRenderer {
-    component: string;
-    storyResult: StoryFnHtmlReturnType;
+  component: string;
+  storyResult: StoryFnHtmlReturnType;
 }
-interface WebComponentsTypes extends WebComponentsRenderer {
-}
-
+interface WebComponentsTypes extends WebComponentsRenderer {}
+//#endregion
+//#region code/renderers/web-components/.dts-emit/code/renderers/web-components/src/public-types.d.ts
 /**
  * Metadata to configure the stories for a component.
  *
  * @see [Default export](https://storybook.js.org/docs/api/csf#default-export)
  */
-type Meta<TArgs = Args> = ComponentAnnotations<WebComponentsRenderer, TArgs>;
+type Meta<TArgs = Args$1> = ComponentAnnotations<WebComponentsRenderer, TArgs>;
 /**
  * Story function that represents a CSFv2 component example.
  *
  * @see [Named Story exports](https://storybook.js.org/docs/api/csf#named-story-exports)
  */
-type StoryFn<TArgs = Args> = AnnotatedStoryFn<WebComponentsRenderer, TArgs>;
+type StoryFn<TArgs = Args$1> = AnnotatedStoryFn<WebComponentsRenderer, TArgs>;
 /**
  * Story object that represents a CSFv3 component example.
  *
  * @see [Named Story exports](https://storybook.js.org/docs/api/csf#named-story-exports)
  */
-type StoryObj<TArgs = Args> = StoryAnnotations<WebComponentsRenderer, TArgs>;
-type Decorator<TArgs = StrictArgs> = DecoratorFunction<WebComponentsRenderer, TArgs>;
-type Loader<TArgs = StrictArgs> = LoaderFunction<WebComponentsRenderer, TArgs>;
-type StoryContext<TArgs = StrictArgs> = StoryContext$1<WebComponentsRenderer, TArgs>;
+type StoryObj<TArgs = Args$1> = StoryAnnotations<WebComponentsRenderer, TArgs>;
+type Decorator<TArgs = StrictArgs$1> = DecoratorFunction<WebComponentsRenderer, TArgs>;
+type Loader<TArgs = StrictArgs$1> = LoaderFunction<WebComponentsRenderer, TArgs>;
+type StoryContext<TArgs = StrictArgs$1> = StoryContext$1<WebComponentsRenderer, TArgs>;
 type Preview = ProjectAnnotations<WebComponentsRenderer>;
-
+//#endregion
+//#region code/renderers/web-components/.dts-emit/code/renderers/web-components/src/framework-api.d.ts
 declare function isValidComponent(tagName: string): boolean;
 declare function isValidMetaData(customElements: any): boolean;
 /** @param customElements `any` for now as spec is not super stable yet */
 declare function setCustomElements(customElements: any): void;
 declare function setCustomElementsManifest(customElements: any): void;
 declare function getCustomElements(): any;
-
+//#endregion
+//#region code/renderers/web-components/.dts-emit/code/renderers/web-components/src/portable-stories.d.ts
 /**
  * Function that sets the globalConfig of your storybook. The global config is the preview module of
  * your .storybook folder.
@@ -61,7 +63,8 @@ declare function getCustomElements(): any;
  * @param projectAnnotations - E.g. (import projectAnnotations from '../.storybook/preview')
  */
 declare function setProjectAnnotations(projectAnnotations: NamedOrDefaultProjectAnnotations<any> | NamedOrDefaultProjectAnnotations<any>[]): NormalizedProjectAnnotations<WebComponentsRenderer>;
-
+//#endregion
+//#region node_modules/type-fest/source/union-to-intersection.d.ts
 /**
 Convert a union type to an intersection type.
 
@@ -79,23 +82,18 @@ type Intersection = UnionToIntersection<Union>;
 
 @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)
-	// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
-	? Intersection & Union
-	: never;
-
+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) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
+//#endregion
+//#region node_modules/type-fest/source/keys-of-union.d.ts
 /**
 Create a union of all keys from a given type, even those exclusive to specific union members.
 
@@ -133,10 +131,10 @@ type AllKeys = KeysOfUnion<Union>;
 
 @category Object
 */
-type KeysOfUnion<ObjectType> =
-	// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
-	keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-
+type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+//#endregion
+//#region node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -166,7 +164,8 @@ const anyA = get(anyObject, 'a');
 @category Utilities
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-
+//#endregion
+//#region node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
 Returns a boolean for whether the given key is an optional key of type.
 
@@ -207,14 +206,9 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Type Guard
 @category Utilities
 */
-type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =
-	IsAny<Type | Key> extends true ? never
-		: Key extends keyof Type
-			? Type extends Record<Key, Type[Key]>
-				? false
-				: true
-			: false;
-
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -248,16 +242,11 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<Type extends object> =
-	Type extends unknown // For distributing `Type`
-		? (keyof {[Key in keyof Type as
-			IsOptionalKeyOf<Type, Key> extends false
-				? never
-				: Key
-			]: never
-		}) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
-		: never; // Should never happen
-
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
+//#endregion
+//#region node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -288,11 +277,10 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 
 @category Utilities
 */
-type RequiredKeysOf<Type extends object> =
-	Type extends unknown // For distributing `Type`
-		? Exclude<keyof Type, OptionalKeysOf<Type>>
-		: never; // Should never happen
-
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+//#endregion
+//#region node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -347,7 +335,8 @@ type B = IsTrueFixed<never>;
 @category Utilities
 */
 type IsNever<T> = [T] extends [never] ? true : false;
-
+//#endregion
+//#region node_modules/type-fest/source/if.d.ts
 /**
 An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
@@ -440,13 +429,9 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 @category Type Guard
 @category Utilities
 */
-type If<Type extends boolean, IfBranch, ElseBranch> =
-	IsNever<Type> extends true
-		? ElseBranch
-		: Type extends true
-			? IfBranch
-			: ElseBranch;
-
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region node_modules/type-fest/source/simplify.d.ts
 /**
 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.
 
@@ -505,8 +490,9 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
-
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -533,20 +519,11 @@ type Includes<Value extends readonly any[], Item> =
 @category Type Guard
 @category Utilities
 */
-type IsEqual<A, B> =
-	[A] extends [B]
-		? [B] extends [A]
-			? _IsEqual<A, B>
-			: false
-		: false;
-
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
-type _IsEqual<A, B> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;
-
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -638,12 +615,9 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @see {@link PickIndexSignature}
 @category Object
 */
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? never
-		: KeyType]: ObjectType[KeyType];
-};
-
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -689,17 +663,11 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @see {@link OmitIndexSignature}
 @category Object
 */
-type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? KeyType
-		: never]: ObjectType[KeyType];
-};
-
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = Simplify<{
-	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
-} & Source>;
-
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
@@ -762,19 +730,14 @@ Note: If you want a merge type that more accurately reflects the runtime behavio
 @see {@link ObjectMerge}
 @category Object
 */
-type Merge<Destination, Source> =
-	Destination extends unknown // For distributing `Destination`
-		? Source extends unknown // For distributing `Source`
-			? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>>
-			: never // Should never happen
-		: never; // Should never happen
-
-type _Merge<Destination, Source> =
-	Simplify<
-		SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
-		& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
-	>;
-
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
 - Distributes over union types and allows picking keys from any member of the union type.
@@ -812,10 +775,7 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
 */
-type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
-	[P in keyof T as Extract<P, Keys>]: T[P]
-};
-
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
 /**
 Merges user specified options with default options.
 
@@ -868,19 +828,9 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<
-	Options extends object,
-	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
-	SpecifiedOptions extends Options,
-> =
-	If<IsAny<SpecifiedOptions>, Defaults,
-		If<IsNever<SpecifiedOptions>, Defaults,
-			Simplify<Merge<Defaults, {
-				[Key in keyof SpecifiedOptions
-				as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key
-				]: SpecifiedOptions[Key]
-			}> & Required<Options>>>>;
-
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+//#endregion
+//#region node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -909,22 +859,17 @@ type Filtered = Filter<'bar', 'foo'>;
 @see {Except}
 */
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
-
 type ExceptOptions = {
-	/**
-	Disallow assigning non-specified properties.
-
-	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-
-	@default false
-	*/
-	requireExactProps?: boolean;
+  /**
+  Disallow assigning non-specified properties.
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
+  */
+  requireExactProps?: boolean;
 };
-
 type DefaultExceptOptions = {
-	requireExactProps: false;
+  requireExactProps: false;
 };
-
 /**
 Create a type from an object type without certain keys.
 
@@ -980,15 +925,10 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 
 @category Object
 */
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
-	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options['requireExactProps'] extends true
-	? Partial<Record<KeysType, never>>
-	: {});
-
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+//#endregion
+//#region node_modules/type-fest/source/set-optional.d.ts
 /**
 Create a type that makes the given keys optional, while keeping the remaining keys as is.
 
@@ -1010,22 +950,13 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 
 @category Object
 */
-type SetOptional<BaseType, Keys extends keyof BaseType> =
-	(BaseType extends (...arguments_: never) => any
-		? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType>
-		: unknown)
-	& _SetOptional<BaseType, Keys>;
-
-type _SetOptional<BaseType, Keys extends keyof BaseType> =
-	BaseType extends unknown // To distribute `BaseType` when it's a union type.
-		? Simplify<
-			// Pick just the keys that are readonly from the base type.
-			Except<BaseType, Keys>
-			// Pick the keys that should be mutable from the base type and make them mutable.
-			& Partial<HomomorphicPick<BaseType, Keys>>
-		>
-		: never;
-
+type SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
+type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
+? Simplify< // Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> // Pick the keys that should be mutable from the base type and make them mutable.
+& Partial<HomomorphicPick<BaseType, Keys>>> : never;
+//#endregion
+//#region code/renderers/web-components/.dts-emit/code/renderers/web-components/src/preview.d.ts
 /**
  * Creates a Web Components-specific preview configuration with CSF factories support.
  *
@@ -1046,11 +977,11 @@ type _SetOptional<BaseType, Keys extends keyof BaseType> =
  * ```
  */
 declare function __definePreview<Addons extends PreviewAddon<never>[]>(input: {
-    addons: Addons;
+  addons: Addons;
 } & ProjectAnnotations<WebComponentsTypes & InferTypes<Addons>>): WebComponentsPreview<WebComponentsTypes & InferTypes<Addons>>;
 type InferArgs<TArgs, T, Decorators> = Simplify<TArgs & Simplify<OmitIndexSignature<DecoratorsArgs<WebComponentsTypes & T, Decorators>>>>;
 type InferWebComponentsTypes<T, TArgs, Decorators> = WebComponentsTypes & T & {
-    args: Simplify<InferArgs<TArgs, T, Decorators>>;
+  args: Simplify<InferArgs<TArgs, T, Decorators>>;
 };
 /**
  * Infers args from a web component's HTMLElement type, allowing both camelCase properties and
@@ -1072,33 +1003,33 @@ type InferArgsFromComponent<C extends keyof HTMLElementTagNameMap> = Partial<HTM
  * ```
  */
 interface WebComponentsPreview<T extends AddonTypes> extends Preview$1<WebComponentsTypes & T> {
-    /**
-     * Narrows the type of the preview to include additional type information. This is useful when you
-     * need to add args that aren't inferred from the component.
-     *
-     * @example
-     *
-     * ```ts
-     * const meta = preview.type<{ args: { theme: 'light' | 'dark' } }>().meta({
-     *   component: 'my-button',
-     * });
-     * ```
-     */
-    type<S>(): WebComponentsPreview<T & S>;
-    meta<C extends keyof HTMLElementTagNameMap, Decorators extends DecoratorFunction<WebComponentsTypes & T, any>, TMetaArgs extends InferArgsFromComponent<C> & Partial<T['args']>>(meta: {
-        component?: C;
-        args?: TMetaArgs;
-        decorators?: Decorators | Decorators[];
-    } & Omit<ComponentAnnotations<WebComponentsTypes & T, InferArgsFromComponent<C> & T['args']>, 'decorators' | 'component' | 'args'>): WebComponentsMeta<InferWebComponentsTypes<T, InferArgsFromComponent<C>, Decorators>, Omit<ComponentAnnotations<InferWebComponentsTypes<T, InferArgsFromComponent<C>, Decorators>>, 'args'> & {
-        args: {} extends TMetaArgs ? {} : TMetaArgs;
-    }>;
-    meta<TArgs, Decorators extends DecoratorFunction<WebComponentsTypes & T, any>, TMetaArgs extends Partial<TArgs>>(meta: {
-        render?: ArgsStoryFn<WebComponentsTypes & T, TArgs>;
-        args?: TMetaArgs;
-        decorators?: Decorators | Decorators[];
-    } & Omit<ComponentAnnotations<WebComponentsTypes & T, TArgs & T['args']>, 'decorators' | 'component' | 'args' | 'render'>): WebComponentsMeta<InferWebComponentsTypes<T, TArgs, Decorators>, Omit<ComponentAnnotations<InferWebComponentsTypes<T, TArgs, Decorators>>, 'args'> & {
-        args: {} extends TMetaArgs ? {} : TMetaArgs;
-    }>;
+  /**
+   * Narrows the type of the preview to include additional type information. This is useful when you
+   * need to add args that aren't inferred from the component.
+   *
+   * @example
+   *
+   * ```ts
+   * const meta = preview.type<{ args: { theme: 'light' | 'dark' } }>().meta({
+   *   component: 'my-button',
+   * });
+   * ```
+   */
+  type<S>(): WebComponentsPreview<T & S>;
+  meta<C extends keyof HTMLElementTagNameMap, Decorators extends DecoratorFunction<WebComponentsTypes & T, any>, TMetaArgs extends InferArgsFromComponent<C> & Partial<T['args']>>(meta: {
+    component?: C;
+    args?: TMetaArgs;
+    decorators?: Decorators | Decorators[];
+  } & Omit<ComponentAnnotations<WebComponentsTypes & T, InferArgsFromComponent<C> & T['args']>, 'decorators' | 'component' | 'args'>): WebComponentsMeta<InferWebComponentsTypes<T, InferArgsFromComponent<C>, Decorators>, Omit<ComponentAnnotations<InferWebComponentsTypes<T, InferArgsFromComponent<C>, Decorators>>, 'args'> & {
+    args: {} extends TMetaArgs ? {} : TMetaArgs;
+  }>;
+  meta<TArgs, Decorators extends DecoratorFunction<WebComponentsTypes & T, any>, TMetaArgs extends Partial<TArgs>>(meta: {
+    render?: ArgsStoryFn<WebComponentsTypes & T, TArgs>;
+    args?: TMetaArgs;
+    decorators?: Decorators | Decorators[];
+  } & Omit<ComponentAnnotations<WebComponentsTypes & T, TArgs & T['args']>, 'decorators' | 'component' | 'args' | 'render'>): WebComponentsMeta<InferWebComponentsTypes<T, TArgs, Decorators>, Omit<ComponentAnnotations<InferWebComponentsTypes<T, TArgs, Decorators>>, 'args'> & {
+    args: {} extends TMetaArgs ? {} : TMetaArgs;
+  }>;
 }
 /** 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>;
@@ -1109,73 +1040,71 @@ type DecoratorsArgs<TRenderer extends Renderer, Decorators> = UnionToIntersectio
  * provided in meta become optional in stories, while missing required args must be provided at the
  * story level.
  */
-interface WebComponentsMeta<T extends WebComponentsTypes, MetaInput extends ComponentAnnotations<T>>
-/** @ts-expect-error WebComponentsMeta requires two type parameters, but Meta's constraints differ */
- extends Meta$1<T, MetaInput> {
-    /**
-     * Creates a story with a custom render function that takes no args.
-     *
-     * This overload allows you to define a story using just a render function or an object with a
-     * render function that doesn't depend on args. Since the render function doesn't use args, no
-     * args need to be provided regardless of what's required by the component.
-     *
-     * @example
-     *
-     * ```ts
-     * // Using just a render function with lit-html
-     * export const CustomTemplate = meta.story(() => html`<div>Custom content</div>`);
-     *
-     * // Using an object with render
-     * export const WithRender = meta.story({
-     *   render: () => html`<my-element></my-element>`,
-     * });
-     * ```
-     */
-    story<TInput extends (() => WebComponentsTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
-        render: () => WebComponentsTypes['storyResult'];
-    })>(story: TInput): WebComponentsStory<T, TInput extends () => WebComponentsTypes['storyResult'] ? {
-        render: TInput;
-    } : TInput>;
-    /**
-     * Creates a story with custom configuration including args, decorators, or other annotations.
-     *
-     * This is the primary overload for defining stories. Args that were already provided in meta
-     * become optional, while any remaining required args must be specified here.
-     *
-     * @example
-     *
-     * ```ts
-     * // Provide required args not in meta
-     * export const Primary = meta.story({
-     *   args: { label: 'Click me', disabled: false },
-     * });
-     *
-     * // Override meta args and add story-specific configuration
-     * export const Disabled = meta.story({
-     *   args: { disabled: true },
-     *   decorators: [withCustomWrapper],
-     * });
-     * ```
-     */
-    story<TInput extends Simplify<StoryAnnotations<T, T['args'], SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']>>>>(story: TInput): WebComponentsStory<T, TInput>;
-    /**
-     * Creates a story with no additional configuration.
-     *
-     * This overload is only available when all required args have been provided in meta. The
-     * conditional type `Partial<T['args']> extends SetOptional<...>` checks if the remaining required
-     * args (after accounting for args provided in meta) are all optional. If so, the function accepts
-     * zero arguments `[]`. Otherwise, it requires `[never]` which makes this overload unmatchable,
-     * forcing the user to provide args.
-     *
-     * @example
-     *
-     * ```ts
-     * // When meta provides all required args, story() can be called with no arguments
-     * const meta = preview.meta({ component: 'my-button', args: { label: 'Hi' } });
-     * export const Default = meta.story(); // Valid - all args provided in meta
-     * ```
-     */
-    story(..._args: Partial<T['args']> extends SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']> ? [] : [never]): WebComponentsStory<T, {}>;
+interface WebComponentsMeta<T extends WebComponentsTypes, MetaInput extends ComponentAnnotations<T>> /** @ts-expect-error WebComponentsMeta requires two type parameters, but Meta's constraints differ */ extends Meta$1<T, MetaInput> {
+  /**
+   * Creates a story with a custom render function that takes no args.
+   *
+   * This overload allows you to define a story using just a render function or an object with a
+   * render function that doesn't depend on args. Since the render function doesn't use args, no
+   * args need to be provided regardless of what's required by the component.
+   *
+   * @example
+   *
+   * ```ts
+   * // Using just a render function with lit-html
+   * export const CustomTemplate = meta.story(() => html`<div>Custom content</div>`);
+   *
+   * // Using an object with render
+   * export const WithRender = meta.story({
+   *   render: () => html`<my-element></my-element>`,
+   * });
+   * ```
+   */
+  story<TInput extends (() => WebComponentsTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
+    render: () => WebComponentsTypes['storyResult'];
+  })>(story: TInput): WebComponentsStory<T, TInput extends (() => WebComponentsTypes['storyResult']) ? {
+    render: TInput;
+  } : TInput>;
+  /**
+   * Creates a story with custom configuration including args, decorators, or other annotations.
+   *
+   * This is the primary overload for defining stories. Args that were already provided in meta
+   * become optional, while any remaining required args must be specified here.
+   *
+   * @example
+   *
+   * ```ts
+   * // Provide required args not in meta
+   * export const Primary = meta.story({
+   *   args: { label: 'Click me', disabled: false },
+   * });
+   *
+   * // Override meta args and add story-specific configuration
+   * export const Disabled = meta.story({
+   *   args: { disabled: true },
+   *   decorators: [withCustomWrapper],
+   * });
+   * ```
+   */
+  story<TInput extends Simplify<StoryAnnotations<T, T['args'], SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']>>>>(story: TInput): WebComponentsStory<T, TInput>;
+  /**
+   * Creates a story with no additional configuration.
+   *
+   * This overload is only available when all required args have been provided in meta. The
+   * conditional type `Partial<T['args']> extends SetOptional<...>` checks if the remaining required
+   * args (after accounting for args provided in meta) are all optional. If so, the function accepts
+   * zero arguments `[]`. Otherwise, it requires `[never]` which makes this overload unmatchable,
+   * forcing the user to provide args.
+   *
+   * @example
+   *
+   * ```ts
+   * // When meta provides all required args, story() can be called with no arguments
+   * const meta = preview.meta({ component: 'my-button', args: { label: 'Hi' } });
+   * export const Default = meta.story(); // Valid - all args provided in meta
+   * ```
+   */
+  story(..._args: Partial<T['args']> extends SetOptional<T['args'], keyof T['args'] & keyof MetaInput['args']> ? [] : [never]): WebComponentsStory<T, {}>;
 }
 /**
  * Web Components-specific Story interface returned by `meta.story()`.
@@ -1183,7 +1112,6 @@ interface WebComponentsMeta<T extends WebComponentsTypes, MetaInput extends Comp
  * Represents a single story with its configuration and provides access to the composed story for
  * testing via `story.run()`.
  */
-interface WebComponentsStory<T extends WebComponentsTypes, TInput extends StoryAnnotations<T, T['args']>> extends Story<T, TInput> {
-}
-
-export { type Decorator, type Loader, type Meta, type Preview, type StoryContext, type StoryFn, type StoryObj, type WebComponentsMeta, type WebComponentsPreview, type WebComponentsRenderer, type WebComponentsStory, type WebComponentsTypes, __definePreview, getCustomElements, isValidComponent, isValidMetaData, setCustomElements, setCustomElementsManifest, setProjectAnnotations };
+interface WebComponentsStory<T extends WebComponentsTypes, TInput extends StoryAnnotations<T, T['args']>> extends Story<T, TInput> {}
+//#endregion
+export { type ArgTypes, type Args, Decorator, Loader, Meta, type Parameters$1 as Parameters, Preview, StoryContext, StoryFn, StoryObj, type StrictArgs, WebComponentsMeta, WebComponentsPreview, type WebComponentsRenderer, WebComponentsStory, type WebComponentsTypes, __definePreview, getCustomElements, isValidComponent, isValidMetaData, setCustomElements, setCustomElementsManifest, setProjectAnnotations };

package/dist/preset.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_2hpvtnd8ya8 from 'node:url';
-import CJS_COMPAT_NODE_PATH_2hpvtnd8ya8 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_2hpvtnd8ya8 from "node:module";
+import CJS_COMPAT_NODE_URL_e9q8fszecqb from 'node:url';
+import CJS_COMPAT_NODE_PATH_e9q8fszecqb from 'node:path';
+import CJS_COMPAT_NODE_MODULE_e9q8fszecqb from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_2hpvtnd8ya8.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_2hpvtnd8ya8.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_2hpvtnd8ya8.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_e9q8fszecqb.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_e9q8fszecqb.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_e9q8fszecqb.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/web-components",
-  "version": "10.6.0-alpha.0",
+  "version": "10.6.0-alpha.2",
   "description": "Storybook Web Components renderer: Develop, document, and test UI components in isolation",
   "keywords": [
     "storybook",
@@ -58,12 +58,12 @@
     "cross-spawn": "^7.0.6",
     "lit": "2.3.1",
     "tmp": "^0.2.3",
-    "typescript": "^5.8.3",
+    "typescript": "^6.0.3",
     "web-component-analyzer": "^1.1.6"
   },
   "peerDependencies": {
     "lit": "^2.0.0 || ^3.0.0",
-    "storybook": "^10.6.0-alpha.0"
+    "storybook": "^10.6.0-alpha.2"
   },
   "publishConfig": {
     "access": "public"