react-cosmos-core 6.0.0-alpha.17 → 6.0.0-alpha.19

package/dist/fixture/useValue/useCurrentValue.d.ts

@@ -1,2 +0,0 @@
-import { FixtureStateData } from '../../fixtureState/types.js';
-export declare function useCurrentValue<T extends FixtureStateData>(inputName: string, defaultValue: T): T;

package/dist/fixture/useValue/useCurrentValue.js

@@ -1,13 +0,0 @@
-import React from 'react';
-import { findFixtureStateControl } from '../../fixtureState/controls.js';
-import { extendWithValue } from '../../fixtureState/extendWithValues.js';
-import { FixtureContext } from '../FixtureContext.js';
-export function useCurrentValue(inputName, defaultValue) {
-    const { fixtureState } = React.useContext(FixtureContext);
-    const fsControl = findFixtureStateControl(fixtureState, inputName);
-    return fsControl && fsControl.type === 'standard'
-        ? // Types of fixture state values cannot be guaranteed at read time, which
-            // means that tampering with the fixture state can cause runtime errors
-            extendWithValue(defaultValue, fsControl.currentValue)
-        : defaultValue;
-}

package/dist/fixture/useValue/useSetValue.d.ts

@@ -1,3 +0,0 @@
-import { FixtureStateData } from '../../fixtureState/types.js';
-import { SetValue } from './shared.js';
-export declare function useSetValue<T extends FixtureStateData>(inputName: string, defaultValue: T): SetValue<T>;

package/dist/fixture/useValue/useSetValue.js

@@ -1,36 +0,0 @@
-import React from 'react';
-import { findFixtureStateControl } from '../../fixtureState/controls.js';
-import { createValue } from '../../fixtureState/createValues.js';
-import { extendWithValue } from '../../fixtureState/extendWithValues.js';
-import { FixtureContext } from '../FixtureContext.js';
-export function useSetValue(inputName, defaultValue) {
-    const { setFixtureState } = React.useContext(FixtureContext);
-    return React.useCallback(stateChange => {
-        setFixtureState(prevFs => {
-            const currentValue = typeof stateChange === 'function'
-                ? stateChange(
-                // Types of fixture state values cannot be guaranteed at read
-                // time, which means that tampering with the fixture state can
-                // cause runtime errors
-                getCurrentValueFromFixtureState(prevFs, inputName, defaultValue))
-                : stateChange;
-            return {
-                ...prevFs,
-                controls: {
-                    ...prevFs.controls,
-                    [inputName]: {
-                        type: 'standard',
-                        defaultValue: createValue(defaultValue),
-                        currentValue: createValue(currentValue),
-                    },
-                },
-            };
-        });
-    }, [setFixtureState, defaultValue, inputName]);
-}
-function getCurrentValueFromFixtureState(fixtureState, inputName, defaultValue) {
-    const fsControl = findFixtureStateControl(fixtureState, inputName);
-    return fsControl && fsControl.type === 'standard'
-        ? extendWithValue(defaultValue, fsControl.currentValue)
-        : defaultValue;
-}

package/dist/playground/playgroundUrl.d.ts

@@ -1,13 +0,0 @@
-import { FixtureId } from '../fixture/types.js';
-export type PlaygroundUrlParams = {
-    fixtureId?: FixtureId;
-};
-export type RendererUrlParams = {
-    _fixtureId?: FixtureId;
-};
-export declare function stringifyPlaygroundUrlQuery(urlParams: PlaygroundUrlParams): string;
-export declare function parsePlaygroundUrlQuery(query: string): PlaygroundUrlParams;
-export declare function stringifyRendererUrlQuery(urlParams: RendererUrlParams): string;
-export declare function parseRendererUrlQuery(query: string): RendererUrlParams;
-export declare function parseUrlQuery<T extends {}>(query: string): T;
-export declare function stringifyUrlQuery(params: {}): string;

package/dist/playground/playgroundUrl.js

@@ -1,36 +0,0 @@
-export function stringifyPlaygroundUrlQuery(urlParams) {
-    const encodedUrlParams = {};
-    if (urlParams.fixtureId) {
-        encodedUrlParams.fixtureId = JSON.stringify(urlParams.fixtureId);
-    }
-    return stringifyUrlQuery(encodedUrlParams);
-}
-export function parsePlaygroundUrlQuery(query) {
-    const encodedUrlParams = parseUrlQuery(query);
-    const decoded = {};
-    if (encodedUrlParams.fixtureId) {
-        decoded.fixtureId = JSON.parse(encodedUrlParams.fixtureId);
-    }
-    return decoded;
-}
-export function stringifyRendererUrlQuery(urlParams) {
-    const encodedUrlParams = {};
-    if (urlParams._fixtureId) {
-        encodedUrlParams._fixtureId = JSON.stringify(urlParams._fixtureId);
-    }
-    return stringifyUrlQuery(encodedUrlParams);
-}
-export function parseRendererUrlQuery(query) {
-    const encodedUrlParams = parseUrlQuery(query);
-    const decoded = {};
-    if (encodedUrlParams._fixtureId) {
-        decoded._fixtureId = JSON.parse(encodedUrlParams._fixtureId);
-    }
-    return decoded;
-}
-export function parseUrlQuery(query) {
-    return Object.fromEntries(new URLSearchParams(query));
-}
-export function stringifyUrlQuery(params) {
-    return new URLSearchParams(params).toString();
-}

package/dist/renderer/DecoratedFixture.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="react" />
-import { FixtureState, SetFixtureState } from '../fixtureState/types.js';
-import { ReactDecorator, ReactDecoratorModule, ReactFixture } from './userModuleTypes.js';
-type Props = {
-    fixture: ReactFixture;
-    systemDecorators: ReactDecorator[];
-    userDecoratorModules: ReactDecoratorModule[];
-    fixtureState: FixtureState;
-    setFixtureState: SetFixtureState;
-    renderKey: number;
-    onErrorReset?: () => unknown;
-};
-export declare function DecoratedFixture({ fixture, systemDecorators, userDecoratorModules, fixtureState, setFixtureState, renderKey, onErrorReset, }: Props): JSX.Element;
-export {};

package/dist/renderer/DecoratedFixture.js

@@ -1,33 +0,0 @@
-import React, { useMemo } from 'react';
-import { FixtureContext } from '../fixture/FixtureContext.js';
-import { getDecoratedFixtureElement } from './getDecoratedFixtureElement/index.js';
-export function DecoratedFixture({ fixture, systemDecorators, userDecoratorModules, fixtureState, setFixtureState, renderKey, onErrorReset = noop, }) {
-    // Prevent unintentional renders https://reactjs.org/docs/context.html#caveats
-    const contextValue = useMemo(() => ({ fixtureState, setFixtureState }), [fixtureState, setFixtureState]);
-    const decoratedFixture = useMemo(() => {
-        const decorators = [
-            ...systemDecorators,
-            ...userDecoratorModules.map(m => m.default),
-        ];
-        return getDecoratedFixtureElement(fixture, decorators, {
-            fixtureState,
-            setFixtureState,
-            onErrorReset,
-        });
-    }, [
-        fixture,
-        fixtureState,
-        onErrorReset,
-        setFixtureState,
-        systemDecorators,
-        userDecoratorModules,
-    ]);
-    return (React.createElement(FixtureContext.Provider
-    // 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, value: contextValue }, decoratedFixture));
-}
-function noop() { }

package/dist/renderer/FixtureCapture/classState/decorateFixtureRefs/index.d.ts

@@ -1,5 +0,0 @@
-import { Component, ReactNode } from 'react';
-import { CachedRefHandlers } from '../shared.js';
-type SpyRef = (elPath: string, elRef: null | Component) => unknown;
-export declare function decorateFixtureRefs(fixture: ReactNode, spyRef: SpyRef, cachedRefHandlers: CachedRefHandlers): ReactNode;
-export {};

package/dist/renderer/FixtureCapture/classState/decorateFixtureRefs/index.js

@@ -1,46 +0,0 @@
-import { cloneElement, } from 'react';
-import { findRelevantElementPaths } from '../../shared/findRelevantElementPaths.js';
-import { setElementAtPath } from '../../shared/nodeTree/index.js';
-import { isRefSupported } from './isRefSupported.js';
-export function decorateFixtureRefs(fixture, spyRef, cachedRefHandlers) {
-    const elPaths = findRelevantElementPaths(fixture);
-    return elPaths.reduce((decoratedFixture, elPath) => {
-        return setElementAtPath(decoratedFixture, elPath, element => {
-            if (!isRefSupported(element.type)) {
-                return element;
-            }
-            return cloneElement(element, {
-                ref: getDecoratedRef(element.ref, spyRef, elPath, cachedRefHandlers),
-            });
-        });
-    }, fixture);
-}
-function getDecoratedRef(origRef, spyRef, elPath, cachedRefHandlers) {
-    const found = cachedRefHandlers[elPath];
-    if (found && found.origRef === origRef) {
-        return found.handler;
-    }
-    const handler = decorateRefWithSpy(origRef, spyRef, elPath);
-    cachedRefHandlers[elPath] = { origRef, handler };
-    return handler;
-}
-function decorateRefWithSpy(origRef, spyRef, elPath) {
-    return (elRef) => {
-        if (origRef) {
-            callOriginalRef(origRef, elRef);
-        }
-        spyRef(elPath, elRef);
-    };
-}
-function callOriginalRef(ref, elRef) {
-    if (typeof ref === 'string') {
-        console.warn('[decorateFixtureRefs] String refs are not supported');
-        return;
-    }
-    if (typeof ref === 'function') {
-        ref(elRef);
-        return;
-    }
-    const refObj = ref;
-    refObj.current = elRef;
-}

package/dist/renderer/FixtureCapture/classState/decorateFixtureRefs/isRefSupported.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-type ElementType = string | React.ComponentType;
-export declare function isRefSupported(elementType: ElementType): boolean;
-export {};

package/dist/renderer/FixtureCapture/classState/decorateFixtureRefs/isRefSupported.js

@@ -1,19 +0,0 @@
-import React from 'react';
-import { ForwardRef } from 'react-is';
-export function isRefSupported(elementType) {
-    if (typeof elementType === 'string') {
-        return false;
-    }
-    const { $$typeof, prototype } = elementType;
-    return ($$typeof === ForwardRef ||
-        // Warning: Some functions don't have the .prototype property
-        (prototype &&
-            // ES6 Class
-            // Warning: This will return false is the component is extending a
-            // different copy of React than the one used by Cosmos. This is relevant
-            // when running Cosmos from an external location instead of node_modules.
-            (prototype instanceof React.Component ||
-                // React.createClass
-                prototype.getInitialState !== undefined) &&
-            true));
-}

package/dist/renderer/FixtureCapture/classState/index.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-import { FixtureDecoratorId } from '../../../fixtureState/types.js';
-export declare function useClassStateCapture(fixture: React.ReactNode, decoratorId: FixtureDecoratorId): React.ReactNode;

package/dist/renderer/FixtureCapture/classState/index.js

@@ -1,13 +0,0 @@
-import React from 'react';
-import { useFixtureState } from './useFixtureState.js';
-import { useReadClassState } from './useReadClassState.js';
-export function useClassStateCapture(fixture, decoratorId) {
-    const elRefs = React.useRef({});
-    React.useEffect(() => {
-        return () => {
-            elRefs.current = {};
-        };
-    }, []);
-    useReadClassState(fixture, decoratorId, elRefs);
-    return useFixtureState(fixture, decoratorId, elRefs);
-}

package/dist/renderer/FixtureCapture/classState/shared.d.ts

@@ -1,18 +0,0 @@
-import React from 'react';
-export type ElRefs = {
-    [elPath: string]: React.Component;
-};
-export type InitialStates = {
-    [elPath: string]: {
-        type: React.ComponentClass<any>;
-        state: {};
-    };
-};
-export type CachedRefHandler = {
-    origRef: null | React.Ref<any>;
-    handler: (elRef: null | React.Component) => unknown;
-};
-export type CachedRefHandlers = {
-    [elPath: string]: CachedRefHandler;
-};
-export declare function replaceState(elRef: React.Component, nextState: {}): void;

package/dist/renderer/FixtureCapture/classState/shared.js

@@ -1,14 +0,0 @@
-import { isEqual } from 'lodash-es';
-// We need to do this because React doesn't provide a replaceState method
-// (anymore) https://reactjs.org/docs/react-component.html#setstate
-export function replaceState(elRef, nextState) {
-    const fullState = resetOriginalKeys(elRef.state, nextState);
-    if (!isEqual(fullState, elRef.state)) {
-        elRef.setState(fullState);
-    }
-}
-function resetOriginalKeys(original, current) {
-    return Object.keys(original).reduce((result, key) => Object.keys(result).indexOf(key) === -1
-        ? { ...result, [key]: undefined }
-        : result, current);
-}

package/dist/renderer/FixtureCapture/classState/useFixtureState.d.ts

@@ -1,4 +0,0 @@
-import { MutableRefObject, ReactNode } from 'react';
-import { FixtureDecoratorId } from '../../../fixtureState/types.js';
-import { ElRefs } from './shared.js';
-export declare function useFixtureState(fixture: ReactNode, decoratorId: FixtureDecoratorId, elRefs: MutableRefObject<ElRefs>): ReactNode;

package/dist/renderer/FixtureCapture/classState/useFixtureState.js

@@ -1,156 +0,0 @@
-import { isEqual } from 'lodash-es';
-import { useContext, useEffect, useRef, } from 'react';
-import { FixtureContext } from '../../../fixture/FixtureContext.js';
-import { createFixtureStateClassState, findFixtureStateClassState, getFixtureStateClassState, removeFixtureStateClassState, } from '../../../fixtureState/classState.js';
-import { createValues } from '../../../fixtureState/createValues.js';
-import { extendWithValues } from '../../../fixtureState/extendWithValues.js';
-import { getComponentName } from '../../../utils/react/getComponentName.js';
-import { findRelevantElementPaths } from '../shared/findRelevantElementPaths.js';
-import { decorateFixtureRefs } from './decorateFixtureRefs/index.js';
-import { replaceState, } from './shared.js';
-export function useFixtureState(fixture, decoratorId, elRefs) {
-    const elPaths = findRelevantElementPaths(fixture);
-    const { fixtureState, setFixtureState } = useContext(FixtureContext);
-    const lastFixtureState = useFixtureStateRef(fixtureState);
-    // Keep a copy of the previous fixture state to observe changes
-    const prevFixtureState = useRef(fixtureState);
-    // Remember initial state of child components to use as a default when
-    // resetting fixture state
-    const initialStates = useRef({});
-    // Ref handlers are reused because every time we pass a new ref handler to
-    // a React element it gets called in the next render loop, even when the
-    // associated element instance has been preserved. Having ref handlers fire
-    // on every render loop results in unwanted operations and race conditions.
-    const cachedRefHandlers = useRef({});
-    useEffect(() => {
-        return () => {
-            initialStates.current = {};
-            cachedRefHandlers.current = {};
-        };
-    }, []);
-    useEffect(() => {
-        // Remove fixture state for removed child elements (likely via HMR)
-        // FIXME: Also invalidate fixture state at this element path if the
-        // component type of the corresponding element changed
-        const fsProps = getFixtureStateClassState(fixtureState, decoratorId);
-        fsProps.forEach(({ elementId }) => {
-            const { elPath } = elementId;
-            if (elPaths.indexOf(elementId.elPath) === -1) {
-                setFixtureState(prevFs => ({
-                    ...prevFs,
-                    classState: removeFixtureStateClassState(fixtureState, elementId),
-                }));
-                if (elRefs.current[elPath]) {
-                    delete elRefs.current[elPath];
-                    delete initialStates.current[elPath];
-                    delete cachedRefHandlers.current[elPath];
-                }
-            }
-        });
-        elPaths.forEach(elPath => {
-            const elementId = { decoratorId, elPath };
-            // Component fixture state can be provided before the fixture mounts (eg.
-            // a previous snapshot of a fixture state or the current fixture state
-            // from another renderer)
-            const fsClassState = findFixtureStateClassState(fixtureState, elementId);
-            if (!fsClassState) {
-                if (initialStates.current[elPath]) {
-                    const { state } = initialStates.current[elPath];
-                    const elRef = elRefs.current[elPath];
-                    if (!isEqual(elRef.state, state)) {
-                        replaceState(elRef, state);
-                    }
-                    setFixtureState(prevFs => ({
-                        ...prevFs,
-                        classState: createFixtureStateClassState({
-                            fixtureState: prevFs,
-                            elementId,
-                            values: createValues(state),
-                            componentName: getComponentName(elRef.constructor),
-                        }),
-                    }));
-                }
-            }
-            else {
-                const elRef = elRefs.current[elPath];
-                // The el ref can be missing for three reasons:
-                //   1. Element type is stateless
-                //   2. Element type is a class, but doesn't have state. An instance exists
-                //      but has been discarded because of its lack of state.
-                //   3. Element instance unmounted and is about to remount. When this
-                //      happens, the new instance will be handled when its ref fires again.
-                if (!elRef) {
-                    return;
-                }
-                // The child's state can be out of sync with the fixture state for two
-                // reasons:
-                //   1. The child's state changed internally
-                //   2. The fixture state changed
-                // Here we're interested in the second scenario. In the first scenario
-                // we want to let the component state override the fixture state.
-                const prevFsClassState = findFixtureStateClassState(prevFixtureState.current, elementId);
-                if (prevFsClassState && !isEqual(prevFsClassState, fsClassState)) {
-                    return replaceState(elRef, extendWithValues(elRef.state, fsClassState.values));
-                }
-            }
-        });
-    }, [
-        decoratorId,
-        elPaths,
-        elRefs,
-        fixtureState,
-        fixtureState.classState,
-        setFixtureState,
-    ]);
-    // Update prev fixture state ref *after* running effects that reference it
-    useEffect(() => {
-        prevFixtureState.current = fixtureState;
-    });
-    return decorateFixtureRefs(fixture, handleRef, cachedRefHandlers.current);
-    function handleRef(elPath, elRef) {
-        if (!elRef) {
-            delete elRefs.current[elPath];
-            return;
-        }
-        // Only track instances with state
-        const { state } = elRef;
-        if (!state) {
-            return;
-        }
-        elRefs.current[elPath] = elRef;
-        setInitialState(initialStates.current, elPath, elRef);
-        const elementId = { decoratorId, elPath };
-        const fsClassState = findFixtureStateClassState(lastFixtureState.current, elementId);
-        if (!fsClassState) {
-            setFixtureState(prevFs => ({
-                ...prevFs,
-                classState: createFixtureStateClassState({
-                    fixtureState: prevFs,
-                    elementId,
-                    values: createValues(state),
-                    componentName: getComponentName(elRef.constructor),
-                }),
-            }));
-        }
-        else {
-            replaceState(elRef, extendWithValues(state, fsClassState.values));
-        }
-    }
-}
-// Make latest fixture state accessible in ref callback
-function useFixtureStateRef(fixtureState) {
-    const ref = useRef(fixtureState);
-    useEffect(() => {
-        ref.current = fixtureState;
-    });
-    return ref;
-}
-function setInitialState(initialStates, elPath, elRef) {
-    const found = initialStates[elPath];
-    const type = elRef.constructor;
-    // Keep the first state recevied for this type
-    const initialStateExists = found && found.type === type;
-    if (!initialStateExists && elRef.state) {
-        initialStates[elPath] = { type, state: elRef.state };
-    }
-}

package/dist/renderer/FixtureCapture/classState/useReadClassState.d.ts

@@ -1,4 +0,0 @@
-import { MutableRefObject, ReactNode } from 'react';
-import { FixtureDecoratorId } from '../../../fixtureState/types.js';
-import { ElRefs } from './shared.js';
-export declare function useReadClassState(fixture: ReactNode, decoratorId: FixtureDecoratorId, elRefs: MutableRefObject<ElRefs>): void;

package/dist/renderer/FixtureCapture/classState/useReadClassState.js

@@ -1,60 +0,0 @@
-import { isEqual } from 'lodash-es';
-import { useContext, useEffect, useRef, } from 'react';
-import { FixtureContext } from '../../../fixture/FixtureContext.js';
-import { findFixtureStateClassState, updateFixtureStateClassState, } from '../../../fixtureState/classState.js';
-import { createValues } from '../../../fixtureState/createValues.js';
-import { extendWithValues } from '../../../fixtureState/extendWithValues.js';
-import { findRelevantElementPaths } from '../shared/findRelevantElementPaths.js';
-// How often to check the state of the loaded component and update the fixture
-// state if it changed
-const REFRESH_INTERVAL = 200;
-export function useReadClassState(fixture, decoratorId, elRefs) {
-    const elPaths = findRelevantElementPaths(fixture);
-    const { fixtureState, setFixtureState } = useContext(FixtureContext);
-    const timeoutId = useRef(null);
-    useEffect(() => {
-        // The check should run even if no element paths are found at mount, because
-        // the fixture can change during the lifecycle of a FixtureCapture instance
-        // and the updated fixture might contain elements of stateful components
-        scheduleStateCheck();
-        return () => {
-            if (timeoutId.current) {
-                clearTimeout(timeoutId.current);
-            }
-        };
-    });
-    function scheduleStateCheck() {
-        // Is there a better way to listen to component state changes?
-        timeoutId.current = window.setTimeout(checkState, REFRESH_INTERVAL);
-    }
-    function checkState() {
-        let fixtureStateChangeScheduled = false;
-        Object.keys(elRefs.current).map(async (elPath) => {
-            if (elPaths.indexOf(elPath) === -1) {
-                throw new Error(`[FixtureCapture] Child ref exists for missing element path "${elPath}"`);
-            }
-            const { state } = elRefs.current[elPath];
-            const elementId = { decoratorId, elPath };
-            const fsClassState = findFixtureStateClassState(fixtureState, elementId);
-            if (fsClassState &&
-                state &&
-                !doesFixtureStateMatchClassState(fsClassState, state)) {
-                fixtureStateChangeScheduled = true;
-                setFixtureState(prevFs => ({
-                    ...prevFs,
-                    classState: updateFixtureStateClassState({
-                        fixtureState: prevFs,
-                        elementId,
-                        values: createValues(state),
-                    }),
-                }));
-            }
-        });
-        if (!fixtureStateChangeScheduled) {
-            scheduleStateCheck();
-        }
-    }
-}
-function doesFixtureStateMatchClassState(fsClassState, state) {
-    return isEqual(state, extendWithValues(state, fsClassState.values));
-}

package/dist/renderer/FixtureCapture/index.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import { FixtureDecoratorId } from '../../fixtureState/types.js';
-export type Props = {
-    children: React.ReactNode;
-    decoratorId: FixtureDecoratorId;
-};
-export declare function FixtureCapture({ children, decoratorId }: Props): JSX.Element;

package/dist/renderer/FixtureCapture/index.js

@@ -1,9 +0,0 @@
-import React from 'react';
-import { useClassStateCapture } from './classState/index.js';
-import { usePropsCapture } from './props/index.js';
-export function FixtureCapture({ children, decoratorId }) {
-    let fixture = usePropsCapture(children, decoratorId);
-    fixture = useClassStateCapture(fixture, decoratorId);
-    // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18051
-    return React.createElement(React.Fragment, null, fixture);
-}

package/dist/renderer/FixtureCapture/props/index.d.ts

@@ -1,3 +0,0 @@
-import { ReactNode } from 'react';
-import { FixtureDecoratorId } from '../../../fixtureState/types.js';
-export declare function usePropsCapture(fixture: ReactNode, decoratorId: FixtureDecoratorId): ReactNode;

package/dist/renderer/FixtureCapture/props/index.js

@@ -1,77 +0,0 @@
-import { useContext, useEffect, useRef } from 'react';
-import { FixtureContext } from '../../../fixture/FixtureContext.js';
-import { createValues } from '../../../fixtureState/createValues.js';
-import { createFixtureStateProps, findFixtureStateProps, getFixtureStateProps, removeFixtureStateProps, updateFixtureStateProps, } from '../../../fixtureState/props.js';
-import { areNodesEqual } from '../../../utils/react/areNodesEqual.js';
-import { getComponentName } from '../../../utils/react/getComponentName.js';
-import { findRelevantElementPaths } from '../shared/findRelevantElementPaths.js';
-import { getElementAtPath, getExpectedElementAtPath, } from '../shared/nodeTree/index.js';
-import { useFixtureProps } from './useFixtureProps.js';
-export function usePropsCapture(fixture, decoratorId) {
-    const { fixtureState, setFixtureState } = useContext(FixtureContext);
-    const prevFixtureRef = useRef(fixture);
-    const elPaths = findRelevantElementPaths(fixture);
-    useEffect(() => {
-        // Create empty fixture state
-        if (!fixtureState.props && elPaths.length === 0) {
-            // Make sure not to override any (currently pending) fixture state props
-            setFixtureState(prevFs => ({ ...prevFs, props: prevFs.props || [] }));
-            return;
-        }
-        // Remove fixture state for removed child elements (likely via HMR)
-        // FIXME: Also invalidate fixture state at this element path if the
-        // component type of the corresponding element changed
-        const fsProps = getFixtureStateProps(fixtureState, decoratorId);
-        fsProps.forEach(({ elementId }) => {
-            if (elPaths.indexOf(elementId.elPath) === -1) {
-                setFixtureState(prevFs => ({
-                    ...prevFs,
-                    props: removeFixtureStateProps(fixtureState, elementId),
-                }));
-            }
-        });
-        elPaths.forEach(elPath => {
-            const childEl = getExpectedElementAtPath(fixture, elPath);
-            const elementId = { decoratorId, elPath };
-            // Component fixture state can be provided before the fixture mounts (eg.
-            // a previous snapshot of a fixture state or the current fixture state
-            // from another renderer)
-            if (!findFixtureStateProps(fixtureState, elementId)) {
-                const componentName = getComponentName(childEl.type);
-                setFixtureState(prevFs => ({
-                    ...prevFs,
-                    props: createFixtureStateProps({
-                        fixtureState: prevFs,
-                        elementId,
-                        values: createValues(childEl.props),
-                        componentName,
-                    }),
-                }));
-            }
-            else {
-                const prevChildEl = getElementAtPath(prevFixtureRef.current, elPath);
-                if (!areNodesEqual(prevChildEl, childEl, false)) {
-                    setFixtureState(prevFs => ({
-                        ...prevFs,
-                        props: updateFixtureStateProps({
-                            fixtureState,
-                            elementId,
-                            values: createValues(childEl.props),
-                        }),
-                    }));
-                }
-            }
-        });
-    }, [
-        fixture,
-        decoratorId,
-        elPaths,
-        fixtureState,
-        fixtureState.props,
-        setFixtureState,
-    ]);
-    useEffect(() => {
-        prevFixtureRef.current = fixture;
-    });
-    return useFixtureProps(fixture, fixtureState, decoratorId);
-}

package/dist/renderer/FixtureCapture/props/useFixtureProps.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-import { FixtureDecoratorId, FixtureState } from '../../../fixtureState/types.js';
-export declare function useFixtureProps(fixture: React.ReactNode, fixtureState: FixtureState, decoratorId: FixtureDecoratorId): React.ReactNode;