@storybook/react-native 8.0.0-alpha.1 → 8.0.0-alpha.3

package/dist/{index.d-ab512c60.d.ts → index.d-3fb25d8d.d.ts}

@@ -21,6 +21,90 @@ declare global {
 	}
 }
 
+/**
+@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;
+
 /**
 Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
 
@@ -799,12 +883,18 @@ interface StrictInputType extends InputType {
 interface Args {
     [name: string]: any;
 }
+type ArgTypes<TArgs = Args> = {
+    [name in keyof TArgs]: InputType;
+};
 type StrictArgTypes<TArgs = Args> = {
     [name in keyof TArgs]: StrictInputType;
 };
 interface Globals {
     [name: string]: any;
 }
+interface GlobalTypes {
+    [name: string]: InputType;
+}
 type Renderer = {
     /** What is the type of the `component` annotation in this renderer? */
     component: unknown;
@@ -825,6 +915,10 @@ interface StoryContextForEnhancers<TRenderer extends Renderer = Renderer, TArgs
     initialArgs: TArgs;
     argTypes: StrictArgTypes<TArgs>;
 }
+type ArgsEnhancer<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContextForEnhancers<TRenderer, TArgs>) => TArgs;
+type ArgTypesEnhancer<TRenderer extends Renderer = Renderer, TArgs = Args> = ((context: StoryContextForEnhancers<TRenderer, TArgs>) => StrictArgTypes<TArgs>) & {
+    secondPass?: boolean;
+};
 interface StoryContextUpdate<TArgs = Args> {
     args?: TArgs;
     globals?: Globals;
@@ -836,16 +930,68 @@ interface StoryContextForLoaders<TRenderer extends Renderer = Renderer, TArgs =
     viewMode: ViewMode$1;
     originalStoryFn: StoryFn<TRenderer>;
 }
+type LoaderFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContextForLoaders<TRenderer, TArgs>) => Promise<Record<string, any> | void> | Record<string, any> | void;
 interface StoryContext<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContextForLoaders<TRenderer, TArgs> {
     loaded: Record<string, any>;
     abortSignal: AbortSignal;
     canvasElement: TRenderer['canvasElement'];
 }
+type StepLabel = string;
+type StepFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs>) => Promise<void> | void;
+type PlayFunctionContext<TRenderer extends Renderer = Renderer, TArgs = Args> = StoryContext<TRenderer, TArgs> & {
+    step: StepFunction<TRenderer, TArgs>;
+};
+type PlayFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: PlayFunctionContext<TRenderer, TArgs>) => Promise<void> | void;
+type PartialStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (update?: StoryContextUpdate<Partial<TArgs>>) => TRenderer['storyResult'];
 type LegacyStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContext<TRenderer, TArgs>) => TRenderer['storyResult'];
 type ArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (args: TArgs, context: StoryContext<TRenderer, TArgs>) => (TRenderer & {
     T: TArgs;
 })['storyResult'];
 type StoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = LegacyStoryFn<TRenderer, TArgs> | ArgsStoryFn<TRenderer, TArgs>;
+type DecoratorFunction<TRenderer extends Renderer = Renderer, TArgs = Args> = (fn: PartialStoryFn<TRenderer, TArgs>, c: StoryContext<TRenderer, TArgs>) => TRenderer['storyResult'];
+type DecoratorApplicator<TRenderer extends Renderer = Renderer, TArgs = Args> = (storyFn: LegacyStoryFn<TRenderer, TArgs>, decorators: DecoratorFunction<TRenderer, TArgs>[]) => LegacyStoryFn<TRenderer, TArgs>;
+type StepRunner<TRenderer extends Renderer = Renderer, TArgs = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs>, context: PlayFunctionContext<TRenderer, TArgs>) => Promise<void>;
+type BaseAnnotations<TRenderer extends Renderer = Renderer, TArgs = Args> = {
+    /**
+     * Wrapper components or Storybook decorators that wrap a story.
+     *
+     * Decorators defined in Meta will be applied to every story variation.
+     * @see [Decorators](https://storybook.js.org/docs/addons/introduction/#1-decorators)
+     */
+    decorators?: DecoratorFunction<TRenderer, Simplify<TArgs>>[] | DecoratorFunction<TRenderer, Simplify<TArgs>>;
+    /**
+     * Custom metadata for a story.
+     * @see [Parameters](https://storybook.js.org/docs/basics/writing-stories/#parameters)
+     */
+    parameters?: Parameters;
+    /**
+     * Dynamic data that are provided (and possibly updated by) Storybook and its addons.
+     * @see [Arg story inputs](https://storybook.js.org/docs/react/api/csf#args-story-inputs)
+     */
+    args?: Partial<TArgs>;
+    /**
+     * ArgTypes encode basic metadata for args, such as `name`, `description`, `defaultValue` for an arg. These get automatically filled in by Storybook Docs.
+     * @see [Control annotations](https://github.com/storybookjs/storybook/blob/91e9dee33faa8eff0b342a366845de7100415367/addons/controls/README.md#control-annotations)
+     */
+    argTypes?: Partial<ArgTypes<TArgs>>;
+    /**
+     * Asynchronous functions which provide data for a story.
+     * @see [Loaders](https://storybook.js.org/docs/react/writing-stories/loaders)
+     */
+    loaders?: LoaderFunction<TRenderer, TArgs>[] | LoaderFunction<TRenderer, TArgs>;
+    /**
+     * Define a custom render function for the story(ies). If not passed, a default render function by the renderer will be used.
+     */
+    render?: ArgsStoryFn<TRenderer, TArgs>;
+};
+type ProjectAnnotations$1<TRenderer extends Renderer = Renderer, TArgs = Args> = BaseAnnotations<TRenderer, TArgs> & {
+    argsEnhancers?: ArgsEnhancer<TRenderer, Args>[];
+    argTypesEnhancers?: ArgTypesEnhancer<TRenderer, Args>[];
+    globals?: Globals;
+    globalTypes?: GlobalTypes;
+    applyDecorators?: DecoratorApplicator<TRenderer, Args>;
+    runStep?: StepRunner<TRenderer, TArgs>;
+};
 
 interface Options$1 {
     allowRegExp: boolean;
@@ -1341,6 +1487,13 @@ interface StorybookConfig {
 type PresetValue<T> = T | ((config: T, options: Options) => T | Promise<T>);
 type Path = string;
 type ModuleExport = any;
+type MaybePromise<T> = Promise<T> | T;
+type TeardownRenderToCanvas = () => MaybePromise<void>;
+type RenderToCanvas<TRenderer extends Renderer> = (context: RenderContext<TRenderer>, element: TRenderer['canvasElement']) => MaybePromise<void | TeardownRenderToCanvas>;
+type ProjectAnnotations<TRenderer extends Renderer> = ProjectAnnotations$1<TRenderer> & {
+    renderToCanvas?: RenderToCanvas<TRenderer>;
+    renderToDOM?: RenderToCanvas<TRenderer>;
+};
 type PreparedStory<TRenderer extends Renderer = Renderer> = StoryContextForEnhancers<TRenderer> & {
     moduleExport: ModuleExport;
     originalStoryFn: StoryFn<TRenderer>;
@@ -1351,5 +1504,17 @@ type PreparedStory<TRenderer extends Renderer = Renderer> = StoryContextForEnhan
     }>;
     playFunction?: (context: StoryContext<TRenderer>) => Promise<void> | void;
 };
+declare type RenderContext<TRenderer extends Renderer = Renderer> = StoryIdentifier & {
+    showMain: () => void;
+    showError: (error: {
+        title: string;
+        description: string;
+    }) => void;
+    showException: (err: Error) => void;
+    forceRemount: boolean;
+    storyContext: StoryContext<TRenderer>;
+    storyFn: PartialStoryFn<TRenderer>;
+    unboundStoryFn: LegacyStoryFn<TRenderer>;
+};
 
-export { Args as A, NormalizedStoriesSpecifier as N, PreparedStory as P, Renderer as R, StoryIndex as S, StorybookConfig as a, StoryContextForEnhancers as b, StrictArgTypes as c };
+export { Args as A, NormalizedStoriesSpecifier as N, PreparedStory as P, Renderer as R, StoryIndex as S, ProjectAnnotations as a, StorybookConfig as b, StoryContextForEnhancers as c, StrictArgTypes as d };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { S as StoryIndex, P as PreparedStory, N as NormalizedStoriesSpecifier, a as StorybookConfig$1 } from './index.d-ab512c60.js';
+import { S as StoryIndex, P as PreparedStory, N as NormalizedStoriesSpecifier, a as ProjectAnnotations, b as StorybookConfig$1 } from './index.d-3fb25d8d.js';
 import { Theme } from '@storybook/react-native-theming';
 export { Theme, darkTheme, theme } from '@storybook/react-native-theming';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -66,16 +66,28 @@ declare class View {
     getStorybookUI: (params?: Partial<Params>) => () => react_jsx_runtime.JSX.Element;
 }
 
+declare function prepareStories({ storyEntries, }: {
+    storyEntries: Array<NormalizedStoriesSpecifier & {
+        req: any;
+    }>;
+}): {
+    index: StoryIndex;
+    importMap: Record<string, any>;
+};
+declare const getProjectAnnotations: (view: View, annotations: any[]) => () => Promise<ProjectAnnotations<ReactRenderer>>;
 declare function start({ annotations, storyEntries, }: {
     storyEntries: Array<NormalizedStoriesSpecifier & {
         req: any;
     }>;
     annotations: any[];
 }): View;
+declare function updateView(viewInstance: View, annotations: any[], normalizedStories: Array<NormalizedStoriesSpecifier & {
+    req: any;
+}>): void;
 
 interface StorybookConfig {
     stories: StorybookConfig$1['stories'];
     addons: string[];
 }
 
-export { StorybookConfig, start };
+export { StorybookConfig, getProjectAnnotations, prepareStories, start, updateView };