react-cosmos-core 6.0.0-alpha.9 → 6.0.0-beta.10

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

@@ -1,9 +1,15 @@
 import { FixtureState } from '../fixtureState/types.js';
-import { FixtureId, FixtureList } from '../fixture/types.js';
+import { FixtureId, FixtureList } from '../userModules/fixtureTypes.js';
 export type RendererId = string;
 export type PingRenderersRequest = {
     type: 'pingRenderers';
 };
+export type ReloadRendererRequest = {
+    type: 'reloadRenderer';
+    payload: {
+        rendererId: RendererId;
+    };
+};
 export type SelectFixtureRequest = {
     type: 'selectFixture';
     payload: {
@@ -26,13 +32,12 @@ export type SetFixtureStateRequest = {
         fixtureState: FixtureState;
     };
 };
-export type RendererRequest = PingRenderersRequest | SelectFixtureRequest | UnselectFixtureRequest | SetFixtureStateRequest;
+export type RendererRequest = PingRenderersRequest | ReloadRendererRequest | SelectFixtureRequest | UnselectFixtureRequest | SetFixtureStateRequest;
 export type RendererReadyResponse = {
     type: 'rendererReady';
     payload: {
         rendererId: RendererId;
-        fixtures: FixtureList;
-        initialFixtureId?: FixtureId;
+        selectedFixtureId?: FixtureId | null;
     };
 };
 export type RendererErrorResponse = {
@@ -65,5 +70,5 @@ export type PlaygroundCommandResponse = {
 export type RendererResponse = RendererReadyResponse | RendererErrorResponse | FixtureListUpdateResponse | FixtureStateChangeResponse | PlaygroundCommandResponse;
 export type RendererConnect<Request = RendererRequest, Response = RendererResponse> = {
     postMessage: (msg: Response) => unknown;
-    onMessage(handler: (msg: Request) => unknown): () => unknown;
+    onMessage(handler: (msg: Request) => unknown): () => void;
 };

package/dist/renderer/rendererConnect.js

@@ -0,0 +1 @@
+export {};

package/dist/renderer/rendererQueryString.d.ts

@@ -0,0 +1,12 @@
+import { FixtureId } from '../userModules/fixtureTypes.js';
+type RendererParams = {
+    fixtureId?: FixtureId;
+    locked?: boolean;
+};
+export type RendererSearchParams = {
+    fixtureId?: string;
+    locked?: string;
+};
+export declare function buildRendererQueryString(params: RendererParams): string;
+export declare function parseRendererQueryString(query: string): RendererParams;
+export {};

package/dist/renderer/rendererQueryString.js

@@ -0,0 +1,27 @@
+import { buildQueryString, parseQueryString } from '../utils/queryString.js';
+export function buildRendererQueryString(params) {
+    return buildQueryString(encodeRendererSearchParams(params));
+}
+export function parseRendererQueryString(query) {
+    return decodeRendererSearchParams(parseQueryString(query));
+}
+function encodeRendererSearchParams(params) {
+    const stringParams = {};
+    if (params.fixtureId) {
+        stringParams.fixtureId = JSON.stringify(params.fixtureId);
+    }
+    if (params.locked) {
+        stringParams.locked = 'true';
+    }
+    return stringParams;
+}
+function decodeRendererSearchParams(stringParams) {
+    const params = {};
+    if (stringParams.fixtureId) {
+        params.fixtureId = JSON.parse(stringParams.fixtureId);
+    }
+    if (stringParams.locked) {
+        params.locked = stringParams.locked === 'true';
+    }
+    return params;
+}

package/dist/renderer/rendererUrl.d.ts

@@ -0,0 +1,9 @@
+import { CosmosCommand } from '../server/serverTypes.js';
+import { FixtureId } from '../userModules/fixtureTypes.js';
+export declare function createRendererUrl(rendererUrl: string, fixtureId?: FixtureId, locked?: boolean): string;
+export declare function pickRendererUrl(rendererUrl: undefined | null | string | {
+    dev: string;
+    export: string;
+}, command: CosmosCommand): null | string;
+export declare function encodeRendererUrlFixture(fixtureId: FixtureId): string;
+export declare function decodeRendererUrlFixture(fixture: string): FixtureId;

package/dist/renderer/rendererUrl.js

@@ -0,0 +1,42 @@
+import { Base64 } from 'js-base64';
+import { buildRendererQueryString } from './rendererQueryString.js';
+export function createRendererUrl(rendererUrl, fixtureId, locked) {
+    if (hasFixtureVar(rendererUrl)) {
+        if (!fixtureId)
+            return replaceFixtureVar(rendererUrl, 'index');
+        return (replaceFixtureVar(rendererUrl, encodeRendererUrlFixture(fixtureId)) +
+            buildRendererQueryString({ locked }));
+    }
+    else {
+        if (!fixtureId)
+            return rendererUrl;
+        const baseUrl = hostOnlyUrl(rendererUrl) ? rendererUrl + '/' : rendererUrl;
+        return baseUrl + buildRendererQueryString({ fixtureId, locked });
+    }
+}
+export function pickRendererUrl(rendererUrl, command) {
+    return rendererUrl && typeof rendererUrl === 'object'
+        ? rendererUrl[command]
+        : rendererUrl ?? null;
+}
+export function encodeRendererUrlFixture(fixtureId) {
+    return Base64.encode(JSON.stringify(fixtureId));
+}
+export function decodeRendererUrlFixture(fixture) {
+    return JSON.parse(Base64.decode(fixture));
+}
+function hasFixtureVar(rendererUrl) {
+    return rendererUrl.includes('<fixture>');
+}
+function replaceFixtureVar(rendererUrl, fixture) {
+    return rendererUrl.replace(/<fixture>/g, fixture);
+}
+function hostOnlyUrl(url) {
+    try {
+        const { protocol, pathname } = new URL(url);
+        return (protocol === 'http:' || protocol === 'https:') && pathname === '/';
+    }
+    catch (err) {
+        return false;
+    }
+}

package/dist/server/serverTypes.d.ts

@@ -0,0 +1 @@
+export type CosmosCommand = 'dev' | 'export';

package/dist/server/serverTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/userModules/fixtureTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/userModules/getFixtureFromExport.d.ts

@@ -0,0 +1,2 @@
+import { ReactFixture, ReactFixtureExport } from './userModuleTypes.js';
+export declare function getFixtureFromExport(fixtureExport: ReactFixtureExport, fixtureName?: string): void | ReactFixture;

package/dist/{renderer/FixtureLoader/fixtureHelpers.js → userModules/getFixtureFromExport.js}

@@ -1,9 +1,10 @@
-import { isMultiFixture } from '../isMultiFixture.js';
-export function getFixture(fixtureExport, fixtureName) {
+import { isMultiFixture } from './isMultiFixture.js';
+export function getFixtureFromExport(fixtureExport, fixtureName) {
     if (fixtureName === undefined) {
         if (isMultiFixture(fixtureExport)) {
             // Fixture name missing in multi fixture
-            return;
+            const fixtureNames = Object.keys(fixtureExport);
+            return fixtureExport[fixtureNames[0]];
         }
         return fixtureExport;
     }

package/dist/userModules/getFixtureList.d.ts

@@ -0,0 +1,7 @@
+import { FixtureList, FixtureListItem } from './fixtureTypes.js';
+import { ByPath, ReactFixtureExport, UserModuleWrappers } from './userModuleTypes.js';
+export declare function getFixtureListFromWrappers(wrappers: UserModuleWrappers): FixtureList;
+export declare function getFixtureListFromExports(exports: ByPath<ReactFixtureExport>): {
+    [x: string]: FixtureListItem;
+};
+export declare function getFixtureItemFromExport(fixtureExport: ReactFixtureExport): FixtureListItem;

package/dist/userModules/getFixtureList.js

@@ -0,0 +1,24 @@
+import { isMultiFixture } from './isMultiFixture.js';
+export function getFixtureListFromWrappers(wrappers) {
+    return Object.keys(wrappers.fixtures).reduce((acc, fixturePath) => {
+        return {
+            ...acc,
+            [fixturePath]: wrappers.lazy
+                ? { type: 'single' }
+                : getFixtureItemFromExport(wrappers.fixtures[fixturePath].module.default),
+        };
+    }, {});
+}
+export function getFixtureListFromExports(exports) {
+    return Object.keys(exports).reduce((acc, fixturePath) => {
+        return {
+            ...acc,
+            [fixturePath]: getFixtureItemFromExport(exports[fixturePath]),
+        };
+    }, {});
+}
+export function getFixtureItemFromExport(fixtureExport) {
+    return isMultiFixture(fixtureExport)
+        ? { type: 'multi', fixtureNames: Object.keys(fixtureExport) }
+        : { type: 'single' };
+}

package/dist/userModules/getSortedDecoratorsForFixturePath.d.ts

@@ -0,0 +1,2 @@
+import { ByPath } from './userModuleTypes.js';
+export declare function getSortedDecoratorsForFixturePath<T>(fixturePath: string, decoratorsByPath: ByPath<T>): T[];

package/dist/{renderer → userModules}/isMultiFixture.d.ts

@@ -1,2 +1,2 @@
-import { ReactFixtureExport, ReactFixtureMap } from './reactTypes.js';
+import { ReactFixtureExport, ReactFixtureMap } from './userModuleTypes.js';
 export declare function isMultiFixture(fixtureExport: ReactFixtureExport): fixtureExport is ReactFixtureMap;

package/dist/userModules/stringifyFixtureId.d.ts

@@ -0,0 +1,2 @@
+import { FixtureId } from './fixtureTypes.js';
+export declare function stringifyFixtureId(fixtureId: FixtureId): string;

package/dist/userModules/stringifyFixtureId.js

@@ -0,0 +1,4 @@
+export function stringifyFixtureId(fixtureId) {
+    const { path, name } = fixtureId;
+    return name ? `${path}-${name}` : path;
+}

package/dist/userModules/userModuleTypes.d.ts

@@ -0,0 +1,44 @@
+import { ComponentType, FunctionComponent, ReactNode } from 'react';
+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;
+};
+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 = {
+    fixtureModule: ReactFixtureModule;
+    decoratorModules: ReactDecoratorModule[];
+};
+export {};

package/dist/userModules/userModuleTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/queryString.d.ts

@@ -0,0 +1,2 @@
+export declare function parseQueryString<T extends {}>(query: string): T;
+export declare function buildQueryString(searchParams: {}): string;

package/dist/utils/queryString.js

@@ -0,0 +1,7 @@
+export function parseQueryString(query) {
+    return Object.fromEntries(new URLSearchParams(query));
+}
+export function buildQueryString(searchParams) {
+    const queryString = new URLSearchParams(searchParams).toString();
+    return queryString && `?${queryString}`;
+}

package/dist/utils/react/ClassStateMock.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+type Props = {
+    children: React.ClassicElement<unknown>;
+    state?: {};
+};
+export declare class ClassStateMock extends React.Component<Props> {
+    static cosmosCapture: boolean;
+    childRef: React.Component | null;
+    render(): React.CElement<unknown, React.Component<{}, {}, any>>;
+    componentDidUpdate(prevProps: Props): void;
+    handleRef: (childRef: React.Component | null) => void;
+}
+export {};

package/dist/utils/react/ClassStateMock.js

@@ -0,0 +1,72 @@
+import { isEqual } from 'lodash-es';
+import React from 'react';
+// Compied from https://github.com/skidding/react-mock/blob/c33dfa1d6f0c9ce7b3eaba073618d61731a0e82e/packages/state/src/index.js
+export class ClassStateMock extends React.Component {
+    static cosmosCapture = false;
+    childRef = null;
+    render() {
+        const { children } = this.props;
+        if (Array.isArray(children)) {
+            throw new Error('ClassStateMock only accepts a single child element');
+        }
+        return React.cloneElement(children, { ref: this.handleRef });
+    }
+    componentDidUpdate(prevProps) {
+        const { childRef } = this;
+        const { state } = this.props;
+        if (!childRef) {
+            throw new Error('childRef missing in ClassStateMock.componentDidUpdate');
+        }
+        if (state && !isEqual(state, prevProps.state)) {
+            replaceState(childRef, state);
+        }
+    }
+    handleRef = (childRef) => {
+        const prevRef = this.props.children.ref;
+        this.childRef = childRef;
+        if (!childRef) {
+            if (prevRef)
+                manuallyCallRef(prevRef, childRef);
+            // Nothing else to do on the unmount branch (when refs are set to NULL)
+            return;
+        }
+        if (this.props.state) {
+            // Wait until state has been set to call prev ref. This will give the
+            // impression that the mocked state is the initial state.
+            replaceState(childRef, this.props.state, () => {
+                manuallyCallRef(prevRef, childRef);
+            });
+        }
+        else {
+            manuallyCallRef(prevRef, childRef);
+        }
+    };
+}
+function replaceState(childRef, state, cb) {
+    // We need to unset existing state keys because React doesn't provide a
+    // replaceState method (anymore)
+    // https://reactjs.org/docs/react-component.html#setstate
+    const nextState = resetOriginalKeys(childRef.state, state);
+    if (!isEqual(nextState, childRef.state)) {
+        childRef.setState(nextState, cb);
+    }
+}
+function resetOriginalKeys(original, current) {
+    const { keys } = Object;
+    return keys(original).reduce((result, key) => keys(result).indexOf(key) === -1
+        ? { ...result, [key]: undefined }
+        : result, current);
+}
+function manuallyCallRef(ref, elRef) {
+    if (typeof ref === 'string') {
+        throw new Error('StateMock does not support string refs');
+    }
+    // https://reactjs.org/docs/refs-and-the-dom.html#creating-refs
+    if (typeof ref === 'function') {
+        ref(elRef);
+    }
+    else if (ref && typeof ref === 'object') {
+        // @ts-ignore
+        ref.current = elRef;
+    }
+}

package/dist/utils/react/DelayRender.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    children: React.ReactNode;
+    delay: number;
+};
+export declare function DelayRender({ children, delay }: Props): React.ReactNode;
+export {};

package/dist/utils/react/DelayRender.js

@@ -0,0 +1,10 @@
+'use client';
+import React from 'react';
+export function DelayRender({ children, delay }) {
+    const [render, setRender] = React.useState(false);
+    React.useEffect(() => {
+        const timeoutId = setTimeout(() => setRender(true), delay);
+        return () => clearTimeout(timeoutId);
+    }, [delay]);
+    return render && children;
+}

package/dist/utils/state.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/string.d.ts

@@ -1,5 +1,3 @@
 export declare function replaceKeys(str: string, map: {
     [key: string]: string;
 }): string;
-export declare function removeLeadingSlash(fromPath: string): string;
-export declare function removeLeadingDot(fromPath: string): string;

package/dist/utils/string.js

@@ -1,9 +1,3 @@
 export function replaceKeys(str, map) {
     return Object.keys(map).reduce((res, key) => res.replace(key, map[key]), str);
 }
-export function removeLeadingSlash(fromPath) {
-    return fromPath.replace(/^\/+/, '');
-}
-export function removeLeadingDot(fromPath) {
-    return fromPath.indexOf('.') === 0 ? fromPath.slice(1) : fromPath;
-}

package/dist/utils/window.d.ts

@@ -0,0 +1 @@
+export declare function isInsideWindowIframe(): boolean;

package/dist/utils/window.js

@@ -0,0 +1,8 @@
+export function isInsideWindowIframe() {
+    try {
+        return window.self !== window.parent;
+    }
+    catch (e) {
+        return true;
+    }
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "react-cosmos-core",
-  "version": "6.0.0-alpha.9",
+  "version": "6.0.0-beta.10",
   "description": "React Cosmos Core",
   "repository": "https://github.com/react-cosmos/react-cosmos/tree/main/packages/react-cosmos-core",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
   "sideEffects": false,
+  "main": "./dist/index.js",
   "dependencies": {
-    "lodash-es": "^4.17.21",
-    "react-is": "^18.2.0"
+    "js-base64": "3.7.5",
+    "lodash-es": "4.17.21",
+    "react-is": "18.2.0"
   },
-  "gitHead": "b155b223f904f5cc29e2f13ac79ab7c4b302ed2b"
+  "gitHead": "6e8136d65a0e78ead6dd27d65e1c08cde6999d26"
 }

package/dist/fixture/FixtureContext.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="react" />
-import { FixtureState, SetFixtureState } from '../fixtureState/types.js';
-export type FixtureContextValue = {
-    fixtureState: FixtureState;
-    setFixtureState: SetFixtureState;
-};
-export declare const FixtureContext: import("react").Context<FixtureContextValue>;

package/dist/fixture/FixtureContext.js

@@ -1,5 +0,0 @@
-import { createContext } from 'react';
-export const FixtureContext = createContext({
-    fixtureState: {},
-    setFixtureState: () => { },
-});

package/dist/fixture/Viewport.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-type Props = {
-    children: React.ReactNode;
-    width: number;
-    height: number;
-};
-export declare const Viewport: React.FC<Props>;
-export {};

package/dist/fixture/Viewport.js

@@ -1,19 +0,0 @@
-import React from 'react';
-import { FixtureContext } from './FixtureContext.js';
-// This awkward declaration is required because of the cosmosCapture static
-// property, which makes TS generate a declaration for Viewport that doesn't
-// conform to React's component interface. Without this explicit type TS would
-// allow clients to pass any props to Viewport.
-export const Viewport = function Viewport({ children, width, height, }) {
-    const { setFixtureState } = React.useContext(FixtureContext);
-    React.useEffect(() => {
-        setFixtureState(fixtureState => ({
-            ...fixtureState,
-            viewport: { width, height },
-        }));
-    }, [setFixtureState, width, height]);
-    // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18051
-    return React.createElement(React.Fragment, null, children);
-};
-// @ts-ignore
-Viewport.cosmosCapture = false;

package/dist/fixture/useSelect/index.d.ts

@@ -1,2 +0,0 @@
-import { SetSelectValue, UseSelectArgs } from './shared.js';
-export declare function useSelect<Option extends string>(selectName: string, args: UseSelectArgs<Option>): [Option, SetSelectValue<Option>];

package/dist/fixture/useSelect/index.js

@@ -1,11 +0,0 @@
-import { useCreateFixtureState } from './useCreateFixtureState.js';
-import { useCurrentValue } from './useCurrentValue.js';
-import { useSetValue } from './useSetValue.js';
-export function useSelect(selectName, args) {
-    if (!args || !args.options || !args.options.length)
-        throw new Error('No options provided to useSelect');
-    useCreateFixtureState(selectName, args);
-    const currentValue = useCurrentValue(selectName, args);
-    const setValue = useSetValue(selectName);
-    return [currentValue, setValue];
-}

package/dist/fixture/useSelect/shared.d.ts

@@ -1,6 +0,0 @@
-export type UseSelectArgs<Option extends string> = {
-    options: Option[];
-    defaultValue?: Option;
-};
-export type SetSelectValue<Option extends string> = (value: Option) => void;
-export declare function getDefaultSelectValue<Option extends string>({ options, defaultValue, }: UseSelectArgs<Option>): Option;

package/dist/fixture/useSelect/shared.js

@@ -1,3 +0,0 @@
-export function getDefaultSelectValue({ options, defaultValue, }) {
-    return typeof defaultValue === 'string' ? defaultValue : options[0];
-}

package/dist/fixture/useSelect/useCreateFixtureState.d.ts

@@ -1,2 +0,0 @@
-import { UseSelectArgs } from './shared.js';
-export declare function useCreateFixtureState<Option extends string>(selectName: string, args: UseSelectArgs<Option>): void;

package/dist/fixture/useSelect/useCreateFixtureState.js

@@ -1,32 +0,0 @@
-import React, { useEffect } from 'react';
-import { findFixtureStateControl } from '../../fixtureState/controls.js';
-import { FixtureContext } from '../FixtureContext.js';
-import { getDefaultSelectValue } from './shared.js';
-export function useCreateFixtureState(selectName, args) {
-    const { setFixtureState } = React.useContext(FixtureContext);
-    const defaultValue = getDefaultSelectValue(args);
-    useEffect(() => {
-        // The fixture state for this select is (re)created in two situations:
-        // 1. Initially: No corresponding fixture state select is found
-        // 2: Default value change: Current value is reset to new default value
-        setFixtureState(prevFs => {
-            const fsControl = findFixtureStateControl(prevFs, selectName);
-            if (fsControl &&
-                fsControl.type === 'select' &&
-                fsControl.defaultValue === defaultValue)
-                return prevFs;
-            return {
-                ...prevFs,
-                controls: {
-                    ...prevFs.controls,
-                    [selectName]: {
-                        type: 'select',
-                        options: args.options,
-                        defaultValue,
-                        currentValue: defaultValue,
-                    },
-                },
-            };
-        });
-    }, [args.options, defaultValue, selectName, setFixtureState]);
-}

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

@@ -1,2 +0,0 @@
-import { UseSelectArgs } from './shared.js';
-export declare function useCurrentValue<Option extends string>(selectName: string, args: UseSelectArgs<Option>): Option;

package/dist/fixture/useSelect/useCurrentValue.js

@@ -1,11 +0,0 @@
-import { useContext } from 'react';
-import { findFixtureStateControl } from '../../fixtureState/controls.js';
-import { FixtureContext } from '../FixtureContext.js';
-import { getDefaultSelectValue } from './shared.js';
-export function useCurrentValue(selectName, args) {
-    const { fixtureState } = useContext(FixtureContext);
-    const fsControl = findFixtureStateControl(fixtureState, selectName);
-    return fsControl && fsControl.type === 'select'
-        ? fsControl.currentValue
-        : getDefaultSelectValue(args);
-}

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

@@ -1,2 +0,0 @@
-import { SetSelectValue } from './shared.js';
-export declare function useSetValue<Option extends string>(selectName: string): SetSelectValue<Option>;

package/dist/fixture/useSelect/useSetValue.js

@@ -1,25 +0,0 @@
-import { useCallback, useContext } from 'react';
-import { findFixtureStateControl } from '../../fixtureState/controls.js';
-import { FixtureContext } from '../FixtureContext.js';
-export function useSetValue(selectName) {
-    const { setFixtureState } = useContext(FixtureContext);
-    return useCallback(value => {
-        setFixtureState(prevFs => {
-            const fsControl = findFixtureStateControl(prevFs, selectName);
-            if (!fsControl || fsControl.type !== 'select') {
-                console.warn(`Invalid fixture state for select: ${selectName}`);
-                return prevFs;
-            }
-            return {
-                ...prevFs,
-                controls: {
-                    ...prevFs.controls,
-                    [selectName]: {
-                        ...fsControl,
-                        currentValue: value,
-                    },
-                },
-            };
-        });
-    }, [selectName, setFixtureState]);
-}

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

@@ -1,7 +0,0 @@
-import { FixtureStateData } from '../../fixtureState/types.js';
-import { SetValue } from './shared.js';
-type Opts<T extends FixtureStateData> = {
-    defaultValue: T;
-};
-export declare function useValue<T extends FixtureStateData>(inputName: string, { defaultValue }: Opts<T>): [T, SetValue<T>];
-export {};

package/dist/fixture/useValue/index.js

@@ -1,9 +0,0 @@
-import { useCreateFixtureState } from './useCreateFixtureState.js';
-import { useCurrentValue } from './useCurrentValue.js';
-import { useSetValue } from './useSetValue.js';
-export function useValue(inputName, { defaultValue }) {
-    useCreateFixtureState(inputName, defaultValue);
-    const currentValue = useCurrentValue(inputName, defaultValue);
-    const setValue = useSetValue(inputName, defaultValue);
-    return [currentValue, setValue];
-}

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

@@ -1,3 +0,0 @@
-import React from 'react';
-import { FixtureStateData } from '../../fixtureState/types.js';
-export type SetValue<T extends FixtureStateData> = React.Dispatch<React.SetStateAction<T>>;

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

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