storybook 9.0.0-alpha.5 → 9.0.0-alpha.7

package/dist/preview-api/index.d.ts

@@ -178,11 +178,11 @@ declare function useReducer<S, I, A>(reducer: (state: S, action: A) => S, initia
  * @returns {void}
  */
 declare function useEffect(create: () => (() => void) | void, deps?: any[]): void;
-interface Listener$1 {
+interface Listener {
     (...args: any[]): void;
 }
 interface EventMap {
-    [eventId: string]: Listener$1;
+    [eventId: string]: Listener;
 }
 /**
  * Subscribes to events emitted by the Storybook channel and returns a function to emit events.
@@ -312,312 +312,6 @@ declare const makeDecorator: ({ name, parameterName, wrapper, skipIfNoParameters
 
 declare function mockChannel(): Channel;
 
-type EnvironmentType = (typeof UniversalStore.Environment)[keyof typeof UniversalStore.Environment];
-type StatusType = (typeof UniversalStore.Status)[keyof typeof UniversalStore.Status];
-type StateUpdater<TState> = (prevState: TState) => TState;
-type Actor = {
-    id: string;
-    type: (typeof UniversalStore.ActorType)[keyof typeof UniversalStore.ActorType];
-    environment: EnvironmentType;
-};
-type EventInfo = {
-    actor: Actor;
-    forwardingActor?: Actor;
-};
-type Listener<TEvent> = (event: TEvent, eventInfo: EventInfo) => void;
-type BaseEvent = {
-    type: string;
-    payload?: any;
-};
-interface SetStateEvent<TState> extends BaseEvent {
-    type: typeof UniversalStore.InternalEventType.SET_STATE;
-    payload: {
-        state: TState;
-        previousState: TState;
-    };
-}
-interface ExistingStateRequestEvent extends BaseEvent {
-    type: typeof UniversalStore.InternalEventType.EXISTING_STATE_REQUEST;
-    payload: never;
-}
-interface ExistingStateResponseEvent<TState> extends BaseEvent {
-    type: typeof UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE;
-    payload: TState;
-}
-interface LeaderCreatedEvent extends BaseEvent {
-    type: typeof UniversalStore.InternalEventType.LEADER_CREATED;
-    payload: never;
-}
-interface FollowerCreatedEvent extends BaseEvent {
-    type: typeof UniversalStore.InternalEventType.FOLLOWER_CREATED;
-    payload: never;
-}
-type InternalEvent<TState> = SetStateEvent<TState> | ExistingStateRequestEvent | ExistingStateResponseEvent<TState> | FollowerCreatedEvent | LeaderCreatedEvent;
-type Event<TState, TEvent extends BaseEvent> = TEvent | InternalEvent<TState>;
-type ChannelLike = Pick<Channel, 'on' | 'off' | 'emit'>;
-type StoreOptions<TState> = {
-    id: string;
-    leader?: boolean;
-    initialState?: TState;
-    debug?: boolean;
-};
-type EnvironmentOverrides = {
-    channel: ChannelLike;
-    environment: EnvironmentType;
-};
-
-/**
- * A universal store implementation that synchronizes state across different environments using a
- * channel-based communication.
- *
- * The store follows a leader-follower pattern where:
- *
- * - Leader: The main store instance that owns and manages the state
- * - Follower: Store instances that mirror the leader's state
- *
- * Features:
- *
- * - State synchronization across environments
- * - Event-based communication
- * - Type-safe state and custom events
- * - Subscription system for state changes and custom events
- *
- * @remarks
- * - The store must be created using the static `create()` method, not the constructor
- * - Follower stores will automatically sync with their leader's state. If they have initial state, it
- *   will be replaced immediately when it has synced with the leader.
- *
- * @example
- *
- * ```typescript
- * interface MyState {
- *   count: number;
- * }
- * interface MyCustomEvent {
- *   type: 'INCREMENT';
- *   payload: number;
- * }
- *
- * // Create a leader store
- * const leaderStore = UniversalStore.create<MyState, MyCustomEvent>({
- *   id: 'my-store',
- *   leader: true,
- *   initialState: { count: 0 },
- * });
- *
- * // Create a follower store
- * const followerStore = UniversalStore.create<MyState, MyCustomEvent>({
- *   id: 'my-store',
- *   leader: false,
- * });
- * ```
- *
- * @template State - The type of state managed by the store
- * @template CustomEvent - Custom events that can be sent through the store. Must have a `type`
- *   string and optional `payload`
- * @throws {Error} If constructed directly instead of using `create()`
- * @throws {Error} If created without setting a channel first
- * @throws {Error} If a follower is created with initial state
- * @throws {Error} If a follower cannot find its leader within 1 second
- */
-declare class UniversalStore<State, CustomEvent extends {
-    type: string;
-    payload?: any;
-} = {
-    type: string;
-    payload?: any;
-}> {
-    /**
-     * Defines the possible actor types in the store system
-     *
-     * @readonly
-     */
-    static readonly ActorType: {
-        readonly LEADER: "LEADER";
-        readonly FOLLOWER: "FOLLOWER";
-    };
-    /**
-     * Defines the possible environments the store can run in
-     *
-     * @readonly
-     */
-    static readonly Environment: {
-        readonly SERVER: "SERVER";
-        readonly MANAGER: "MANAGER";
-        readonly PREVIEW: "PREVIEW";
-        readonly UNKNOWN: "UNKNOWN";
-        readonly MOCK: "MOCK";
-    };
-    /**
-     * Internal event types used for store synchronization
-     *
-     * @readonly
-     */
-    static readonly InternalEventType: {
-        readonly EXISTING_STATE_REQUEST: "__EXISTING_STATE_REQUEST";
-        readonly EXISTING_STATE_RESPONSE: "__EXISTING_STATE_RESPONSE";
-        readonly SET_STATE: "__SET_STATE";
-        readonly LEADER_CREATED: "__LEADER_CREATED";
-        readonly FOLLOWER_CREATED: "__FOLLOWER_CREATED";
-    };
-    static readonly Status: {
-        readonly UNPREPARED: "UNPREPARED";
-        readonly SYNCING: "SYNCING";
-        readonly READY: "READY";
-        readonly ERROR: "ERROR";
-    };
-    protected static isInternalConstructing: boolean;
-    /**
-     * The preparation construct is used to keep track of all store's preparation state the promise is
-     * resolved when the store is prepared with the static __prepare() method which will also change
-     * the state from PENDING to RESOLVED
-     */
-    private static preparation;
-    private static setupPreparationPromise;
-    /** Enable debug logs for this store */
-    debugging: boolean;
-    /** The actor object representing the store instance with a unique ID and a type */
-    get actor(): Actor;
-    /**
-     * The current state of the store, that signals both if the store is prepared by Storybook and
-     * also - in the case of a follower - if the state has been synced with the leader's state.
-     */
-    get status(): StatusType;
-    /**
-     * A promise that resolves when the store is fully ready. A leader will be ready when the store
-     * has been prepared by Storybook, which is almost instantly.
-     *
-     * A follower will be ready when the state has been synced with the leader's state, within a few
-     * hundred milliseconds.
-     */
-    untilReady(): Promise<[{
-        channel: ChannelLike;
-        environment: EnvironmentType;
-    }, void | undefined]>;
-    /**
-     * The syncing construct is used to keep track of if the instance's state has been synced with the
-     * other instances. A leader will immediately have the promise resolved. A follower will initially
-     * be in a PENDING state, and resolve the the leader has sent the existing state, or reject if no
-     * leader has responded before the timeout.
-     */
-    private syncing?;
-    private channelEventName;
-    private state;
-    private channel?;
-    private environment?;
-    private listeners;
-    private id;
-    private actorId;
-    private actorType;
-    protected constructor(options: StoreOptions<State>, environmentOverrides?: EnvironmentOverrides);
-    /** Creates a new instance of UniversalStore */
-    static create<State = any, CustomEvent extends {
-        type: string;
-        payload?: any;
-    } = {
-        type: string;
-        payload?: any;
-    }>(options: StoreOptions<State>): UniversalStore<State, CustomEvent>;
-    /** Gets the current state */
-    getState: () => State;
-    /**
-     * Updates the store's state
-     *
-     * Either a new state or a state updater function can be passed to the method.
-     */
-    setState(updater: State | StateUpdater<State>): void;
-    /**
-     * Subscribes to store events
-     *
-     * @returns A function to unsubscribe
-     */
-    subscribe: {
-        (listener: Listener<Event<State, CustomEvent>>): () => void;
-        <EventType extends Event<State, CustomEvent>['type']>(eventType: EventType, listener: Listener<Extract<Event<State, CustomEvent>, {
-            type: EventType;
-        }>>): () => void;
-    };
-    /**
-     * Subscribes to state changes
-     *
-     * @returns Unsubscribe function
-     */
-    onStateChange(listener: (state: State, previousState: State, eventInfo: EventInfo) => void): () => void;
-    /** Sends a custom event to the other stores */
-    send: (event: CustomEvent) => void;
-    private emitToChannel;
-    private prepareThis;
-    private emitToListeners;
-    private handleChannelEvents;
-    private debug;
-}
-
-/**
- * A hook to use a UniversalStore in a rendered preview. This hook will react to changes in the
- * store state and re-render when the store changes.
- *
- * @param universalStore The UniversalStore instance to use.
- * @param selector An optional selector function to select a subset of the store state.
- * @remark This hook is intended for use in the preview. For use in the manager UI, import from
- * `storybook/manager-api` instead.
- */
-declare const useUniversalStore: {
-    <TUniversalStore extends UniversalStore<TState, any>, TState = TUniversalStore extends UniversalStore<infer S, any> ? S : never>(universalStore: TUniversalStore): [TState, TUniversalStore['setState']];
-    <TUniversalStore extends UniversalStore<any, any>, TSelectedState, TState = TUniversalStore extends UniversalStore<infer S, any> ? S : never>(universalStore: TUniversalStore, selector: (state: TState) => TSelectedState): [TSelectedState, TUniversalStore['setState']];
-};
-
-/**
- * A mock universal store that can be used when testing code that relies on a universal store. It
- * functions exactly like a normal universal store, with a few exceptions:
- *
- * - It is fully isolated, meaning that it doesn't interact with any channel, and it is always a
- *   leader.
- *
- * If the second testUtils argument is provided, all the public methods are spied on, so they can be
- * asserted.
- *
- * When a mock store is re-used across tests (eg. in stories), you manually need to reset the state
- * after each test.
- *
- * @example
- *
- * ```ts
- * import * as testUtils from 'storybook/test'; // in stories
- * import { vi as testUtils } from 'vitest'; // ... or in Vitest tests
- *
- * const initialState = { ... };
- * const store = new MockUniversalStore({ initialState }, testUtils);
- *
- * export default {
- *   title: 'My story',
- *   beforeEach: () => {
- *     return () => {
- *       store.setState(initialState);
- *     };
- *   }
- * }
- * ```
- */
-declare class MockUniversalStore<State, CustomEvent extends {
-    type: string;
-    payload?: any;
-} = {
-    type: string;
-    payload?: any;
-}> extends UniversalStore<State, CustomEvent> {
-    private testUtils;
-    constructor(options: StoreOptions<State>, testUtils?: any);
-    /** Create a mock universal store. This is just an alias for the constructor */
-    static create<State = any, CustomEvent extends {
-        type: string;
-        payload?: any;
-    } = {
-        type: string;
-        payload?: any;
-    }>(options: StoreOptions<State>, testUtils?: any): MockUniversalStore<State, CustomEvent>;
-    unsubscribeAll(): void;
-}
-
 declare class ArgsStore {
     initialArgsByStoryId: Record<StoryId, Args>;
     argsByStoryId: Record<StoryId, Args>;
@@ -1397,4 +1091,4 @@ declare type RenderContext<TRenderer extends Renderer = Renderer> = StoryIdentif
 declare function getCoreAnnotations(): any[];
 declare function getComposedCoreAnnotations<TRenderer extends Renderer$1>(): NormalizedProjectAnnotations<TRenderer>;
 
-export { DocsContext, HooksContext, Preview, PreviewWeb, PreviewWithSelection, type PropDescriptor, type Report, ReporterAPI, type SelectionStore, StoryStore, UrlStore, type View, WebView, addons, applyHooks, combineArgs, combineParameters, composeConfigs, composeStepRunners, composeStories, composeStory, createPlaywrightTest, decorateStory, defaultDecorateStory, definePreview, MockUniversalStore as experimental_MockUniversalStore, UniversalStore as experimental_UniversalStore, useUniversalStore as experimental_useUniversalStore, filterArgTypes, getComposedCoreAnnotations, getCoreAnnotations, getCsfFactoryAnnotations, inferControls, makeDecorator, mockChannel, normalizeProjectAnnotations, normalizeStory, prepareMeta, prepareStory, sanitizeStoryContextUpdate, setDefaultProjectAnnotations, setProjectAnnotations, simulateDOMContentLoaded, simulatePageLoad, sortStoriesV7, useArgs, useCallback, useChannel, useEffect, useGlobals, useMemo, useParameter, useReducer, useRef, useState, useStoryContext, userOrAutoTitle, userOrAutoTitleFromSpecifier };
+export { DocsContext, HooksContext, Preview, PreviewWeb, PreviewWithSelection, type PropDescriptor, type Report, ReporterAPI, type SelectionStore, StoryStore, UrlStore, type View, WebView, addons, applyHooks, combineArgs, combineParameters, composeConfigs, composeStepRunners, composeStories, composeStory, createPlaywrightTest, decorateStory, defaultDecorateStory, definePreview, filterArgTypes, getComposedCoreAnnotations, getCoreAnnotations, getCsfFactoryAnnotations, inferControls, makeDecorator, mockChannel, normalizeProjectAnnotations, normalizeStory, prepareMeta, prepareStory, sanitizeStoryContextUpdate, setDefaultProjectAnnotations, setProjectAnnotations, simulateDOMContentLoaded, simulatePageLoad, sortStoriesV7, useArgs, useCallback, useChannel, useEffect, useGlobals, useMemo, useParameter, useReducer, useRef, useState, useStoryContext, userOrAutoTitle, userOrAutoTitleFromSpecifier };