react-cosmos-core 6.0.0-alpha.9 → 6.0.0-canary.03b80da.0

package/dist/renderer/{types.d.ts → rendererConnectTypes.d.ts}

@@ -1,5 +1,5 @@
+import { FixtureId, FixtureList, FixtureListItem } from '../fixture/types.js';
 import { FixtureState } from '../fixtureState/types.js';
-import { FixtureId, FixtureList } from '../fixture/types.js';
 export type RendererId = string;
 export type PingRenderersRequest = {
     type: 'pingRenderers';
@@ -48,6 +48,14 @@ export type FixtureListUpdateResponse = {
         fixtures: FixtureList;
     };
 };
+export type FixtureListItemUpdateResponse = {
+    type: 'fixtureListItemUpdate';
+    payload: {
+        rendererId: RendererId;
+        fixturePath: string;
+        fixtureItem: FixtureListItem;
+    };
+};
 export type FixtureStateChangeResponse = {
     type: 'fixtureStateChange';
     payload: {
@@ -62,7 +70,7 @@ export type PlaygroundCommandResponse = {
         command: string;
     };
 };
-export type RendererResponse = RendererReadyResponse | RendererErrorResponse | FixtureListUpdateResponse | FixtureStateChangeResponse | PlaygroundCommandResponse;
+export type RendererResponse = RendererReadyResponse | RendererErrorResponse | FixtureListUpdateResponse | FixtureListItemUpdateResponse | FixtureStateChangeResponse | PlaygroundCommandResponse;
 export type RendererConnect<Request = RendererRequest, Response = RendererResponse> = {
     postMessage: (msg: Response) => unknown;
     onMessage(handler: (msg: Request) => unknown): () => unknown;

package/dist/renderer/useFixtureModules.d.ts

@@ -0,0 +1,2 @@
+import { FixtureModules, ReactDecoratorWrapper, ReactFixtureWrapper } from './userModuleTypes.js';
+export declare function useFixtureModules(fixturePath: string, fixtureWrapper: ReactFixtureWrapper, decoratorWrappers: ReactDecoratorWrapper[]): FixtureModules;

package/dist/renderer/useFixtureModules.js

@@ -0,0 +1,10 @@
+import { useMemo } from 'react';
+export function useFixtureModules(fixturePath, fixtureWrapper, decoratorWrappers) {
+    return useMemo(() => {
+        return {
+            fixturePath,
+            fixtureModule: fixtureWrapper.module,
+            decoratorModules: decoratorWrappers.map(d => d.module),
+        };
+    }, [decoratorWrappers, fixturePath, fixtureWrapper]);
+}

package/dist/renderer/useLazyFixtureModules.d.ts

@@ -0,0 +1,2 @@
+import { FixtureModules, LazyReactDecoratorWrapper, LazyReactFixtureWrapper } from './userModuleTypes.js';
+export declare function useLazyFixtureModules(fixturePath: string, fixtureWrapper: LazyReactFixtureWrapper, decoratorWrappers: LazyReactDecoratorWrapper[]): FixtureModules | null;

package/dist/renderer/useLazyFixtureModules.js

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react';
+export function useLazyFixtureModules(fixturePath, fixtureWrapper, decoratorWrappers) {
+    const [modules, setModules] = useState(null);
+    useEffect(() => {
+        let canceled = false;
+        (async () => {
+            const fixtureModule = await fixtureWrapper.getModule();
+            const decoratorModules = await Promise.all(decoratorWrappers.map(d => d.getModule()));
+            if (!canceled) {
+                setModules({
+                    fixturePath,
+                    fixtureModule,
+                    decoratorModules,
+                });
+            }
+        })();
+        return () => {
+            canceled = true;
+        };
+    }, [decoratorWrappers, fixturePath, fixtureWrapper]);
+    // Stop returning modules once fixturePath changed to prevent rendering
+    // the previous fixture until the new fixture modules are loaded
+    return modules && modules.fixturePath === fixturePath ? modules : null;
+}

package/dist/renderer/useRendererRequest.d.ts

@@ -0,0 +1,5 @@
+import { Dispatch, SetStateAction } from 'react';
+import { RendererConnect } from './rendererConnectTypes.js';
+import { UserModuleWrappers } from './userModuleTypes.js';
+import { SelectedFixture } from './useSelectedFixture.js';
+export declare function useRendererRequest(rendererId: string, rendererConnect: RendererConnect, moduleWrappers: UserModuleWrappers, setSelectedFixture: Dispatch<SetStateAction<SelectedFixture | null>>, onErrorReset?: () => unknown): void;

package/dist/renderer/useRendererRequest.js

@@ -0,0 +1,81 @@
+import { isEqual } from 'lodash-es';
+import { useEffect } from 'react';
+import { getFixtureListFromWrappers } from './getFixtureList.js';
+export function useRendererRequest(rendererId, rendererConnect, moduleWrappers, setSelectedFixture, onErrorReset) {
+    useEffect(() => {
+        function postReadyState() {
+            const fixtures = getFixtureListFromWrappers(moduleWrappers);
+            rendererConnect.postMessage({
+                type: 'rendererReady',
+                payload: { rendererId, fixtures },
+            });
+        }
+        function fireChangeCallback() {
+            if (typeof onErrorReset === 'function') {
+                onErrorReset();
+            }
+        }
+        function handleSelectFixtureRequest({ payload }) {
+            const { fixtureId, fixtureState } = payload;
+            setSelectedFixture(prev => {
+                return {
+                    fixtureId,
+                    fixtureState,
+                    syncedFixtureState: fixtureState,
+                    renderKey: prev ? prev.renderKey + 1 : 0,
+                };
+            });
+        }
+        function handleUnselectFixtureRequest() {
+            setSelectedFixture(null);
+        }
+        function handleSetFixtureStateRequest({ payload }) {
+            const { fixtureId, fixtureState } = payload;
+            setSelectedFixture(prev => {
+                // Ensure fixture state applies to currently selected fixture
+                if (prev && isEqual(prev.fixtureId, fixtureId)) {
+                    return {
+                        ...prev,
+                        fixtureState,
+                        syncedFixtureState: fixtureState,
+                    };
+                }
+                else {
+                    return prev;
+                }
+            });
+        }
+        const unsubscribe = rendererConnect.onMessage((msg) => {
+            if (msg.type === 'pingRenderers') {
+                return postReadyState();
+            }
+            if (!msg.payload || msg.payload.rendererId !== rendererId) {
+                return;
+            }
+            const doesRequestChangeFixture = msg.type === 'selectFixture' || msg.type === 'unselectFixture';
+            if (doesRequestChangeFixture) {
+                fireChangeCallback();
+            }
+            switch (msg.type) {
+                case 'selectFixture':
+                    return handleSelectFixtureRequest(msg);
+                case 'unselectFixture':
+                    return handleUnselectFixtureRequest();
+                case 'setFixtureState':
+                    return handleSetFixtureStateRequest(msg);
+                default:
+                // Ignore all other messages, which could be unrelated browser
+                // devtools communications.
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [
+        moduleWrappers,
+        onErrorReset,
+        rendererConnect,
+        rendererId,
+        setSelectedFixture,
+    ]);
+}

package/dist/renderer/useRendererResponse.d.ts

@@ -0,0 +1,4 @@
+import { FixtureId } from '../fixture/types.js';
+import { RendererConnect } from './rendererConnectTypes.js';
+import { UserModuleWrappers } from './userModuleTypes.js';
+export declare function useRendererResponse(rendererId: string, rendererConnect: RendererConnect, moduleWrappers: UserModuleWrappers, initialFixtureId?: FixtureId): void;

package/dist/renderer/useRendererResponse.js

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react';
+import { getFixtureListFromWrappers } from './getFixtureList.js';
+export function useRendererResponse(rendererId, rendererConnect, moduleWrappers, initialFixtureId) {
+    const readyRef = useRef(false);
+    useEffect(() => {
+        const fixtures = getFixtureListFromWrappers(moduleWrappers);
+        if (readyRef.current) {
+            rendererConnect.postMessage({
+                type: 'fixtureListUpdate',
+                payload: { rendererId, fixtures },
+            });
+        }
+        else {
+            rendererConnect.postMessage({
+                type: 'rendererReady',
+                payload: initialFixtureId
+                    ? { rendererId, fixtures, initialFixtureId }
+                    : { rendererId, fixtures },
+            });
+            readyRef.current = true;
+        }
+    }, [initialFixtureId, moduleWrappers, rendererConnect, rendererId]);
+}

package/dist/renderer/useSelectedFixture.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { FixtureId } from '../fixture/types.js';
+import { FixtureState, SetFixtureState } from '../fixtureState/types.js';
+export type SelectedFixture = {
+    fixtureId: FixtureId;
+    fixtureState: FixtureState;
+    syncedFixtureState: FixtureState;
+    renderKey: number;
+};
+export declare function useSelectedFixture(initialFixtureId?: FixtureId, selectedFixtureId?: null | FixtureId): {
+    selectedFixture: SelectedFixture | null;
+    setSelectedFixture: import("react").Dispatch<import("react").SetStateAction<SelectedFixture | null>>;
+    setFixtureState: SetFixtureState;
+};

package/dist/renderer/useSelectedFixture.js

@@ -0,0 +1,31 @@
+import { useCallback, useState } from 'react';
+export function useSelectedFixture(initialFixtureId, selectedFixtureId) {
+    const [selectedFixture, setSelectedFixture] = useState(() => {
+        const fixtureId = selectedFixtureId ?? initialFixtureId;
+        if (!fixtureId)
+            return null;
+        return {
+            fixtureId,
+            fixtureState: {},
+            syncedFixtureState: {},
+            renderKey: 0,
+        };
+    });
+    const setFixtureState = useCallback(stateUpdate => {
+        setSelectedFixture(prevState => {
+            if (!prevState) {
+                console.warn('Trying to set fixture state with no fixture selected');
+                return null;
+            }
+            return {
+                ...prevState,
+                fixtureState: stateUpdate(prevState.fixtureState),
+            };
+        });
+    }, [setSelectedFixture]);
+    return {
+        selectedFixture,
+        setSelectedFixture,
+        setFixtureState,
+    };
+}

package/dist/renderer/userModuleTypes.d.ts

@@ -0,0 +1,49 @@
+import { ComponentType, FunctionComponent, ReactNode } from 'react';
+import { FixtureState, SetFixtureState } from '../fixtureState/types.js';
+type FixtureMap<FixtureType> = {
+    [fixtureName: string]: FixtureType;
+};
+type FixtureExport<FixtureType> = FixtureType | FixtureMap<FixtureType>;
+type FixtureModule<FixtureType> = {
+    default: FixtureExport<FixtureType>;
+};
+type ModuleWrapper<ModuleType> = {
+    module: ModuleType;
+};
+type LazyModuleWrapper<ModuleType> = {
+    getModule: () => Promise<ModuleType>;
+};
+export type ReactFixture = ReactNode | FunctionComponent;
+export type ReactFixtureMap = FixtureMap<ReactFixture>;
+export type ReactFixtureExport = FixtureExport<ReactFixture>;
+export type ReactFixtureModule = FixtureModule<ReactFixture>;
+export type ReactFixtureWrapper = ModuleWrapper<ReactFixtureModule>;
+export type LazyReactFixtureWrapper = LazyModuleWrapper<ReactFixtureModule>;
+export type ReactDecoratorProps = {
+    children: ReactNode;
+    fixtureState: FixtureState;
+    setFixtureState: SetFixtureState;
+    onErrorReset: () => unknown;
+};
+export type ReactDecorator = ComponentType<ReactDecoratorProps>;
+export type ReactDecoratorModule = {
+    default: ReactDecorator;
+};
+export type ReactDecoratorWrapper = ModuleWrapper<ReactDecoratorModule>;
+export type LazyReactDecoratorWrapper = LazyModuleWrapper<ReactDecoratorModule>;
+export type ByPath<T> = Record<string, T>;
+export type UserModuleWrappers = {
+    lazy: true;
+    fixtures: ByPath<LazyReactFixtureWrapper>;
+    decorators: ByPath<LazyReactDecoratorWrapper>;
+} | {
+    lazy: false;
+    fixtures: ByPath<ReactFixtureWrapper>;
+    decorators: ByPath<ReactDecoratorWrapper>;
+};
+export type FixtureModules = {
+    fixturePath: string;
+    fixtureModule: ReactFixtureModule;
+    decoratorModules: ReactDecoratorModule[];
+};
+export {};

package/dist/server/cosmosPluginConfig.d.ts

@@ -1,15 +1,13 @@
 export type RawCosmosPluginConfig = {
     name: string;
     ui?: string;
-    devServer?: string;
-    export?: string;
+    server?: string;
 };
 export type CosmosPluginConfig = {
     name: string;
     rootDir: string;
     ui?: string;
-    devServer?: string;
-    export?: string;
+    server?: string;
 };
 export type UiCosmosPluginConfig = CosmosPluginConfig & {
     ui: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-cosmos-core",
-  "version": "6.0.0-alpha.9",
+  "version": "6.0.0-canary.03b80da.0+03b80da",
   "description": "React Cosmos Core",
   "repository": "https://github.com/react-cosmos/react-cosmos/tree/main/packages/react-cosmos-core",
   "license": "MIT",
@@ -11,5 +11,5 @@
     "lodash-es": "^4.17.21",
     "react-is": "^18.2.0"
   },
-  "gitHead": "b155b223f904f5cc29e2f13ac79ab7c4b302ed2b"
+  "gitHead": "03b80da1b8741a929868d74771832dde14fcba2b"
 }

package/dist/renderer/FixtureLoader/FixtureLoader.d.ts

@@ -1,52 +0,0 @@
-import React, { Component, ReactNode } from 'react';
-import { FixtureId } from '../../fixture/types.js';
-import { FixtureState, SetFixtureState } from '../../fixtureState/types.js';
-import { ReactDecorator, ReactDecorators, ReactFixtureWrappers } from '../reactTypes.js';
-import { RendererConnect, RendererRequest, RendererResponse, SelectFixtureRequest, SetFixtureStateRequest } from '../types.js';
-export type Props = {
-    rendererId: string;
-    rendererConnect: RendererConnect;
-    fixtures: ReactFixtureWrappers;
-    initialFixtureId?: FixtureId;
-    selectedFixtureId?: null | FixtureId;
-    systemDecorators: ReactDecorator[];
-    userDecorators: ReactDecorators;
-    renderMessage?: (args: {
-        msg: string;
-    }) => ReactNode;
-    onErrorReset?: () => unknown;
-};
-type SelectedFixture = {
-    fixtureId: FixtureId;
-    fixtureState: FixtureState;
-    syncedFixtureState: FixtureState;
-};
-type State = {
-    selectedFixture: null | SelectedFixture;
-    renderKey: number;
-};
-export declare class FixtureLoader extends Component<Props, State> {
-    state: State;
-    unsubscribe: null | (() => unknown);
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    componentDidUpdate(prevProps: Props): void;
-    shouldComponentUpdate(prevProps: Props, prevState: State): boolean;
-    render(): string | number | boolean | React.ReactFragment | JSX.Element | null | undefined;
-    handleRequest: (msg: RendererRequest) => void;
-    handleSelectFixtureRequest({ payload }: SelectFixtureRequest): void;
-    handleUnselectFixtureRequest(): void;
-    handleSetFixtureStateRequest({ payload }: SetFixtureStateRequest): void;
-    postReadyState(): void;
-    postFixtureListUpdate(): void;
-    postFixtureStateChange: (fixtureId: FixtureId, fixtureState: FixtureState) => void;
-    setFixtureState: SetFixtureState;
-    getFixtureList(): {
-        [x: string]: import("../../fixture/types.js").FixtureListItem;
-    };
-    fireChangeCallback(): void;
-    updateSyncedFixtureState(syncedFixtureState: FixtureState): void;
-    postMessage(msg: RendererResponse): void;
-    renderMessage(msg: string): React.ReactNode;
-}
-export {};

package/dist/renderer/FixtureLoader/FixtureLoader.js

@@ -1,226 +0,0 @@
-import { isEqual } from 'lodash-es';
-import React, { Component } from 'react';
-import { getFixtureListFromWrappers } from '../getFixtureList.js';
-import { getFixture } from './fixtureHelpers.js';
-import { FixtureProvider } from './FixtureProvider.js';
-function getSelectedFixtureState(fixtureId) {
-    if (!fixtureId)
-        return null;
-    return {
-        fixtureId: fixtureId,
-        fixtureState: {},
-        syncedFixtureState: {},
-    };
-}
-export class FixtureLoader extends Component {
-    state = {
-        selectedFixture: getSelectedFixtureState(this.props.selectedFixtureId || this.props.initialFixtureId),
-        renderKey: 0,
-    };
-    unsubscribe = null;
-    componentDidMount() {
-        if (!this.props.selectedFixtureId) {
-            const { rendererConnect } = this.props;
-            this.unsubscribe = rendererConnect.onMessage(this.handleRequest);
-            this.postReadyState();
-        }
-    }
-    componentWillUnmount() {
-        if (this.unsubscribe)
-            this.unsubscribe();
-    }
-    componentDidUpdate(prevProps) {
-        const { fixtures } = this.props;
-        if (!isEqual(fixtures, prevProps.fixtures)) {
-            this.postFixtureListUpdate();
-        }
-        const { selectedFixture } = this.state;
-        if (selectedFixture) {
-            const { fixtureId, fixtureState, syncedFixtureState } = selectedFixture;
-            if (fixtureId && !isEqual(fixtureState, syncedFixtureState)) {
-                this.postFixtureStateChange(fixtureId, fixtureState);
-                this.updateSyncedFixtureState(fixtureState);
-            }
-        }
-    }
-    shouldComponentUpdate(prevProps, prevState) {
-        // This check exists mainly to prevent updating the fixture tree when
-        // fixture state setters resulted in no fixture state change
-        return !isEqual(this.props, prevProps) || !isEqual(this.state, prevState);
-    }
-    render() {
-        const { selectedFixture } = this.state;
-        if (!selectedFixture) {
-            return this.renderMessage('No fixture selected.');
-        }
-        const { fixtures } = this.props;
-        const { fixtureId, fixtureState } = selectedFixture;
-        // Falsy check doesn't do because fixtures can be any Node, including
-        // null or undefined.
-        if (!fixtures.hasOwnProperty(fixtureId.path)) {
-            return this.renderMessage(`Fixture path not found: ${fixtureId.path}`);
-        }
-        const fixtureExport = fixtures[fixtureId.path].module.default;
-        const fixture = getFixture(fixtureExport, fixtureId.name);
-        if (typeof fixture === 'undefined') {
-            return this.renderMessage(`Invalid fixture ID: ${JSON.stringify(fixtureId)}`);
-        }
-        const { systemDecorators, userDecorators, onErrorReset } = this.props;
-        const { renderKey } = this.state;
-        return (React.createElement(FixtureProvider
-        // renderKey controls whether to reuse previous instances (and
-        // transition props) or rebuild render tree from scratch
-        , { 
-            // renderKey controls whether to reuse previous instances (and
-            // transition props) or rebuild render tree from scratch
-            key: renderKey, fixtureId: fixtureId, fixture: fixture, systemDecorators: systemDecorators, userDecorators: userDecorators, fixtureState: fixtureState, setFixtureState: this.setFixtureState, onErrorReset: onErrorReset || noop }));
-    }
-    handleRequest = (msg) => {
-        if (msg.type === 'pingRenderers') {
-            return this.postReadyState();
-        }
-        if (!msg.payload || msg.payload.rendererId !== this.props.rendererId) {
-            return;
-        }
-        if (doesRequestChangeFixture(msg)) {
-            this.fireChangeCallback();
-        }
-        switch (msg.type) {
-            case 'selectFixture':
-                return this.handleSelectFixtureRequest(msg);
-            case 'unselectFixture':
-                return this.handleUnselectFixtureRequest();
-            case 'setFixtureState':
-                return this.handleSetFixtureStateRequest(msg);
-            default:
-            // This Is Fine™
-            // Actually, we can't be angry about getting unrelated messages here
-            // because we don't do any preliminary message filtering to ignore stuff
-            // like browser devtools communication, nor do we have any message
-            // metadata conventions in place to perform such filtering at the moment
-        }
-    };
-    handleSelectFixtureRequest({ payload }) {
-        const { fixtureId, fixtureState } = payload;
-        this.setState({
-            selectedFixture: {
-                fixtureId,
-                fixtureState,
-                syncedFixtureState: fixtureState,
-            },
-            renderKey: this.state.renderKey + 1,
-        });
-    }
-    handleUnselectFixtureRequest() {
-        this.setState({
-            selectedFixture: null,
-            renderKey: 0,
-        });
-    }
-    handleSetFixtureStateRequest({ payload }) {
-        const { fixtureId, fixtureState } = payload;
-        const { selectedFixture } = this.state;
-        // Ensure fixture state applies to currently selected fixture
-        if (selectedFixture && isEqual(fixtureId, selectedFixture.fixtureId)) {
-            this.setState({
-                selectedFixture: {
-                    fixtureId,
-                    fixtureState,
-                    syncedFixtureState: fixtureState,
-                },
-            });
-        }
-    }
-    postReadyState() {
-        const { rendererId, initialFixtureId } = this.props;
-        const fixtures = this.getFixtureList();
-        this.postMessage({
-            type: 'rendererReady',
-            payload: initialFixtureId
-                ? { rendererId, fixtures, initialFixtureId }
-                : { rendererId, fixtures },
-        });
-    }
-    postFixtureListUpdate() {
-        const { rendererId } = this.props;
-        this.postMessage({
-            type: 'fixtureListUpdate',
-            payload: {
-                rendererId,
-                fixtures: this.getFixtureList(),
-            },
-        });
-    }
-    postFixtureStateChange = (fixtureId, fixtureState) => {
-        const { rendererId } = this.props;
-        this.postMessage({
-            type: 'fixtureStateChange',
-            payload: {
-                rendererId,
-                fixtureId,
-                fixtureState,
-            },
-        });
-    };
-    setFixtureState = stateUpdate => {
-        if (!this.state.selectedFixture) {
-            console.warn('[FixtureLoader] Trying to set fixture state with no fixture selected');
-            return;
-        }
-        // Multiple state changes can be dispatched by fixture plugins at almost
-        // the same time. Since state changes are batched in React, current state
-        // (this.state.fixtureState) can be stale at dispatch time, and extending
-        // it can result in cancelling previous state changes that are queued.
-        // Using an updater function like ({ prevState }) => nextState ensures
-        // every state change is honored, regardless of timing.
-        this.setState(({ selectedFixture }) => {
-            if (!selectedFixture) {
-                return null;
-            }
-            return {
-                selectedFixture: {
-                    ...selectedFixture,
-                    fixtureState: stateUpdate(selectedFixture.fixtureState),
-                },
-            };
-        });
-    };
-    getFixtureList() {
-        return getFixtureListFromWrappers(this.props.fixtures);
-    }
-    fireChangeCallback() {
-        const { onErrorReset } = this.props;
-        if (typeof onErrorReset === 'function') {
-            onErrorReset();
-        }
-    }
-    updateSyncedFixtureState(syncedFixtureState) {
-        this.setState(({ selectedFixture }) => {
-            if (!selectedFixture) {
-                return null;
-            }
-            // Other updates that alter state.selectedFixture can be pending when this
-            // update is submitted. Those updates will be applied first. With this in
-            // mind, we use a state setter callback to only override syncedFixtureState
-            // and keep the latest values of other state parts.
-            return {
-                selectedFixture: {
-                    ...selectedFixture,
-                    syncedFixtureState,
-                },
-            };
-        });
-    }
-    postMessage(msg) {
-        this.props.rendererConnect.postMessage(msg);
-    }
-    renderMessage(msg) {
-        return typeof this.props.renderMessage !== 'undefined'
-            ? this.props.renderMessage({ msg })
-            : msg;
-    }
-}
-function doesRequestChangeFixture(r) {
-    return r.type === 'selectFixture' || r.type === 'unselectFixture';
-}
-function noop() { }

package/dist/renderer/FixtureLoader/FixtureProvider.d.ts

@@ -1,18 +0,0 @@
-import { ReactNode } from 'react';
-import { FixtureId } from '../../fixture/types.js';
-import { FixtureState, SetFixtureState } from '../../fixtureState/types.js';
-import { ReactDecorator, ReactDecorators, ReactFixture } from '../reactTypes.js';
-type Props = {
-    fixtureId: FixtureId;
-    fixture: ReactFixture;
-    systemDecorators: ReactDecorator[];
-    userDecorators: ReactDecorators;
-    fixtureState: FixtureState;
-    setFixtureState: SetFixtureState;
-    renderMessage?: (args: {
-        msg: string;
-    }) => ReactNode;
-    onErrorReset: () => unknown;
-};
-export declare function FixtureProvider({ fixtureId, fixture, systemDecorators, userDecorators, fixtureState, setFixtureState, onErrorReset, }: Props): JSX.Element;
-export {};

package/dist/renderer/FixtureLoader/FixtureProvider.js

@@ -1,18 +0,0 @@
-import React, { useMemo } from 'react';
-import { FixtureContext } from '../../fixture/FixtureContext.js';
-import { getSortedDecoratorsForFixturePath } from '../getSortedDecoratorsForFixturePath.js';
-import { getDecoratedFixtureElement } from './getDecoratedFixtureElement/index.js';
-export function FixtureProvider({ fixtureId, fixture, systemDecorators, userDecorators, fixtureState, setFixtureState, onErrorReset, }) {
-    // Prevent unintentional renders https://reactjs.org/docs/context.html#caveats
-    const contextValue = useMemo(() => ({ fixtureState, setFixtureState }), [fixtureState, setFixtureState]);
-    const decoratorProps = useMemo(() => ({ fixtureState, setFixtureState, onErrorReset }), [fixtureState, onErrorReset, setFixtureState]);
-    const decorators = useMemo(() => mergeDecorators(fixtureId, systemDecorators, userDecorators), [fixtureId, systemDecorators, userDecorators]);
-    const decoratedFixture = useMemo(() => getDecoratedFixtureElement(fixture, decorators, decoratorProps), [decoratorProps, decorators, fixture]);
-    return (React.createElement(FixtureContext.Provider, { value: contextValue }, decoratedFixture));
-}
-function mergeDecorators(fixtureId, systemDecorators, userDecorators) {
-    return [
-        ...systemDecorators,
-        ...getSortedDecoratorsForFixturePath(fixtureId.path, userDecorators),
-    ];
-}

package/dist/renderer/reactTypes.d.ts

@@ -1,28 +0,0 @@
-import { ComponentType, FunctionComponent, ReactNode } from 'react';
-import { FixtureState, SetFixtureState } from '../fixtureState/types.js';
-type FixtureMap<FixtureType> = {
-    [fixtureName: string]: FixtureType;
-};
-type FixtureExport<FixtureType> = FixtureType | FixtureMap<FixtureType>;
-type FixtureModule<FixtureType> = {
-    default: FixtureExport<FixtureType>;
-};
-type FixtureWrapper<FixtureType> = {
-    module: FixtureModule<FixtureType>;
-};
-export type ReactFixture = ReactNode | FunctionComponent;
-export type ReactFixtureMap = FixtureMap<ReactFixture>;
-export type ReactFixtureExport = FixtureExport<ReactFixture>;
-export type ReactFixtureModule = FixtureModule<ReactFixture>;
-export type ReactFixtureWrapper = FixtureWrapper<ReactFixture>;
-export type ReactDecoratorProps = {
-    children: ReactNode;
-    fixtureState: FixtureState;
-    setFixtureState: SetFixtureState;
-    onErrorReset: () => unknown;
-};
-export type ReactDecorator = ComponentType<ReactDecoratorProps>;
-export type ReactFixtureExports = Record<string, ReactFixtureExport>;
-export type ReactFixtureWrappers = Record<string, ReactFixtureWrapper>;
-export type ReactDecorators = Record<string, ReactDecorator>;
-export {};