@storybook/preact 10.3.0-alpha.6 → 10.3.0-alpha.8

package/dist/index.d.ts

@@ -1,10 +1,201 @@
-import { WebRenderer, Args, ComponentAnnotations, AnnotatedStoryFn, StoryAnnotations, StrictArgs, DecoratorFunction, LoaderFunction, StoryContext as StoryContext$1, ProjectAnnotations, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations } from 'storybook/internal/types';
+import { WebRenderer, Args, ComponentAnnotations, AnnotatedStoryFn, ArgsStoryFn, ArgsFromMeta, StoryAnnotations, StrictArgs, DecoratorFunction, LoaderFunction, StoryContext as StoryContext$1, ProjectAnnotations, NamedOrDefaultProjectAnnotations, NormalizedProjectAnnotations } from 'storybook/internal/types';
 export { ArgTypes, Args, Parameters, StrictArgs } from 'storybook/internal/types';
-import { AnyComponent } from 'preact';
+import { AnyComponent, ComponentType, ComponentProps } from 'preact';
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+*/
+type IsEqual<T, U> =
+	(<G>() => G extends T ? 1 : 2) extends
+	(<G>() => G extends U ? 1 : 2)
+		? true
+		: false;
+
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+
+/**
+Create a type from an object type without certain keys.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+	c: boolean;
+};
+
+type FooWithoutA = Except<Foo, 'a' | 'c'>;
+//=> {b: string};
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+};
+
+/**
+@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;
+
+/**
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import type {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+}
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+// type SomeOptional = {
+// 	a: number;
+// 	b?: string; // Was already optional and still is.
+// 	c?: boolean; // Is now optional.
+// }
+```
+
+@category Object
+*/
+type SetOptional<BaseType, Keys extends keyof BaseType> =
+	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<Pick<BaseType, Keys>>
+	>;
 
 type StoryFnPreactReturnType = string | Node | preact.JSX.Element;
 interface PreactRenderer extends WebRenderer {
-    component: AnyComponent<any, any>;
+    component: AnyComponent<this['T'], any>;
     storyResult: StoryFnPreactReturnType;
 }
 
@@ -13,19 +204,30 @@ interface PreactRenderer extends WebRenderer {
  *
  * @see [Default export](https://storybook.js.org/docs/api/csf#default-export)
  */
-type Meta<TArgs = Args> = ComponentAnnotations<PreactRenderer, TArgs>;
+type Meta<TCmpOrArgs = Args> = [TCmpOrArgs] extends [ComponentType<any>] ? ComponentAnnotations<PreactRenderer, ComponentProps<TCmpOrArgs>> : ComponentAnnotations<PreactRenderer, TCmpOrArgs>;
 /**
  * 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<PreactRenderer, TArgs>;
+type StoryFn<TCmpOrArgs = Args> = [TCmpOrArgs] extends [ComponentType<any>] ? AnnotatedStoryFn<PreactRenderer, ComponentProps<TCmpOrArgs>> : AnnotatedStoryFn<PreactRenderer, TCmpOrArgs>;
 /**
  * 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<PreactRenderer, TArgs>;
+type StoryObj<TMetaOrCmpOrArgs = Args> = [TMetaOrCmpOrArgs] extends [
+    {
+        render?: ArgsStoryFn<PreactRenderer, any>;
+        component?: infer Component;
+        args?: infer DefaultArgs;
+    }
+] ? Simplify<(Component extends ComponentType<any> ? ComponentProps<Component> : unknown) & ArgsFromMeta<PreactRenderer, TMetaOrCmpOrArgs>> extends infer TArgs ? StoryAnnotations<PreactRenderer, AddMocks<TArgs, DefaultArgs>, SetOptional<TArgs, keyof TArgs & keyof DefaultArgs>> : never : TMetaOrCmpOrArgs extends ComponentType<any> ? StoryAnnotations<PreactRenderer, ComponentProps<TMetaOrCmpOrArgs>> : StoryAnnotations<PreactRenderer, TMetaOrCmpOrArgs>;
+type AddMocks<TArgs, DefaultArgs> = Simplify<{
+    [T in keyof TArgs]: T extends keyof DefaultArgs ? DefaultArgs[T] extends (...args: any) => any & {
+        mock: {};
+    } ? DefaultArgs[T] : TArgs[T] : TArgs[T];
+}>;
 type Decorator<TArgs = StrictArgs> = DecoratorFunction<PreactRenderer, TArgs>;
 type Loader<TArgs = StrictArgs> = LoaderFunction<PreactRenderer, TArgs>;
 type StoryContext<TArgs = StrictArgs> = StoryContext$1<PreactRenderer, TArgs>;
@@ -52,4 +254,4 @@ type Preview = ProjectAnnotations<PreactRenderer>;
  */
 declare function setProjectAnnotations(projectAnnotations: NamedOrDefaultProjectAnnotations<any> | NamedOrDefaultProjectAnnotations<any>[]): NormalizedProjectAnnotations<PreactRenderer>;
 
-export { type Decorator, type Loader, type Meta, type PreactRenderer, type Preview, type StoryContext, type StoryFn, type StoryObj, setProjectAnnotations };
+export { type AddMocks, type Decorator, type Loader, type Meta, type PreactRenderer, type Preview, type StoryContext, type StoryFn, type StoryObj, setProjectAnnotations };

package/dist/preset.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_i0ypi7go5ll from 'node:url';
-import CJS_COMPAT_NODE_PATH_i0ypi7go5ll from 'node:path';
-import CJS_COMPAT_NODE_MODULE_i0ypi7go5ll from "node:module";
+import CJS_COMPAT_NODE_URL_yfv24zeatri from 'node:url';
+import CJS_COMPAT_NODE_PATH_yfv24zeatri from 'node:path';
+import CJS_COMPAT_NODE_MODULE_yfv24zeatri from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_i0ypi7go5ll.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_i0ypi7go5ll.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_i0ypi7go5ll.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_yfv24zeatri.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_yfv24zeatri.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_yfv24zeatri.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/preact",
-  "version": "10.3.0-alpha.6",
+  "version": "10.3.0-alpha.8",
   "description": "Storybook Preact renderer: Develop, document, and test UI components in isolation",
   "keywords": [
     "storybook",
@@ -53,7 +53,7 @@
   },
   "peerDependencies": {
     "preact": "^8.0.0||^10.0.0",
-    "storybook": "^10.3.0-alpha.6"
+    "storybook": "^10.3.0-alpha.8"
   },
   "publishConfig": {
     "access": "public"