react-cosmos-core 6.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Ovidiu Cherecheș
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/fixture/FixtureContext.d.ts

@@ -0,0 +1,7 @@
+/// <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

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

package/dist/fixture/Viewport.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,19 @@
+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/types.d.ts

@@ -0,0 +1,13 @@
+export type FixtureId = {
+    path: string;
+    name?: string;
+};
+export type FixtureListItem = {
+    type: 'single';
+} | {
+    type: 'multi';
+    fixtureNames: string[];
+};
+export type FixtureList = {
+    [fixturePath: string]: FixtureListItem;
+};

package/dist/fixture/types.js

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

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,6 @@
+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

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

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

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

package/dist/fixture/useSelect/useCreateFixtureState.js

@@ -0,0 +1,32 @@
+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

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

package/dist/fixture/useSelect/useCurrentValue.js

@@ -0,0 +1,11 @@
+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

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

package/dist/fixture/useSelect/useSetValue.js

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,3 @@
+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/shared.js

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

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

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

package/dist/fixture/useValue/useCreateFixtureState.js

@@ -0,0 +1,35 @@
+import { isEqual } from 'lodash-es';
+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 useCreateFixtureState(inputName, defaultValue) {
+    const { setFixtureState } = React.useContext(FixtureContext);
+    React.useEffect(() => {
+        // The fixture state for this value is (re)created in two situations:
+        // 1. Initially: No corresponding fixture state value is found
+        // 2: Default value change: Current value is reset to new default value
+        setFixtureState(prevFs => {
+            const fsControl = findFixtureStateControl(prevFs, inputName);
+            if (fsControl &&
+                fsControl.type === 'standard' &&
+                fsValueExtendsBaseValue(fsControl.defaultValue, defaultValue))
+                return prevFs;
+            return {
+                ...prevFs,
+                controls: {
+                    ...prevFs.controls,
+                    [inputName]: {
+                        type: 'standard',
+                        defaultValue: createValue(defaultValue),
+                        currentValue: createValue(defaultValue),
+                    },
+                },
+            };
+        });
+    }, [setFixtureState, inputName, defaultValue]);
+}
+function fsValueExtendsBaseValue(fsValue, baseValue) {
+    return isEqual(baseValue, extendWithValue(baseValue, fsValue));
+}

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

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

package/dist/fixture/useValue/useCurrentValue.js

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,36 @@
+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/fixtureState/classState.d.ts

@@ -0,0 +1,22 @@
+import { FixtureDecoratorId, FixtureElementId, FixtureState, FixtureStateClassState, FixtureStateValues } from './types.js';
+export declare function getFixtureStateClassState(fixtureState: FixtureState, decoratorId: FixtureDecoratorId): FixtureStateClassState[];
+export declare function findFixtureStateClassState(fixtureState: FixtureState, elementId: FixtureElementId): void | FixtureStateClassState;
+type CreateFixtureStateClassStateArgs = {
+    fixtureState: FixtureState;
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+    componentName: string;
+};
+export declare function createFixtureStateClassState({ fixtureState, elementId, values, componentName, }: CreateFixtureStateClassStateArgs): {
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+    componentName: string;
+}[];
+type UpdateFixtureStateClassStateArgs = {
+    fixtureState: FixtureState;
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+};
+export declare function updateFixtureStateClassState({ fixtureState, elementId, values, }: UpdateFixtureStateClassStateArgs): FixtureStateClassState[];
+export declare function removeFixtureStateClassState(fixtureState: FixtureState, elementId: FixtureElementId): FixtureStateClassState[];
+export {};

package/dist/fixtureState/classState.js

@@ -0,0 +1,40 @@
+import { find, isEqual } from 'lodash-es';
+import { removeItemMatch, replaceOrAddItem, updateItem, } from '../utils/array.js';
+export function getFixtureStateClassState(fixtureState, decoratorId) {
+    const { classState } = fixtureState;
+    return classState
+        ? classState.filter(s => s.elementId.decoratorId === decoratorId)
+        : [];
+}
+export function findFixtureStateClassState(fixtureState, elementId) {
+    const { classState } = fixtureState;
+    return classState && find(classState, s => isEqual(s.elementId, elementId));
+}
+export function createFixtureStateClassState({ fixtureState, elementId, values, componentName, }) {
+    const { classState = [] } = fixtureState;
+    return replaceOrAddItem(classState, createClassStateMatcher(elementId), {
+        elementId,
+        values,
+        componentName,
+    });
+}
+export function updateFixtureStateClassState({ fixtureState, elementId, values, }) {
+    const classStateItem = expectFixtureStateClassState(fixtureState, elementId);
+    return updateItem(fixtureState.classState, classStateItem, {
+        values,
+    });
+}
+export function removeFixtureStateClassState(fixtureState, elementId) {
+    return removeItemMatch(fixtureState.classState || [], createClassStateMatcher(elementId));
+}
+function createClassStateMatcher(elementId) {
+    return (p) => isEqual(p.elementId, elementId);
+}
+function expectFixtureStateClassState(fixtureState, elementId) {
+    const classStateItem = findFixtureStateClassState(fixtureState, elementId);
+    if (!classStateItem) {
+        const elId = JSON.stringify(elementId);
+        throw new Error(`Fixture state class state missing for element "${elId}"`);
+    }
+    return classStateItem;
+}

package/dist/fixtureState/controls.d.ts

@@ -0,0 +1,2 @@
+import { FixtureState, FixtureStateControl } from './types.js';
+export declare function findFixtureStateControl(fixtureState: FixtureState, inputName: string): void | FixtureStateControl;

package/dist/fixtureState/controls.js

@@ -0,0 +1,4 @@
+export function findFixtureStateControl(fixtureState, inputName) {
+    const { controls } = fixtureState;
+    return controls && controls[inputName];
+}

package/dist/fixtureState/createValues.d.ts

@@ -0,0 +1,3 @@
+import { FixtureStateValue, FixtureStateValues, ObjectData } from './types.js';
+export declare function createValues(obj: ObjectData): FixtureStateValues;
+export declare function createValue(data: unknown): FixtureStateValue;

package/dist/fixtureState/createValues.js

@@ -0,0 +1,39 @@
+import { isElement } from 'react-is';
+import { isArray, isObject, isPrimitiveData } from './shared.js';
+export function createValues(obj) {
+    const values = {};
+    Object.keys(obj).forEach(key => {
+        values[key] = createValue(obj[key]);
+    });
+    return values;
+}
+export function createValue(data) {
+    if (isPrimitiveData(data))
+        return { type: 'primitive', data };
+    if (isArray(data))
+        return {
+            type: 'array',
+            values: data.map(i => createValue(i)),
+        };
+    if (isObject(data))
+        return {
+            type: 'object',
+            values: createValues(data),
+        };
+    // Why store unserializable values in fixture state?
+    // - Because they still provides value in the Cosmos UI. They let the user know
+    //   that, eg. a prop, is present and see the read-only stringified value.
+    // - More importantly, because the fixture state controls which props to render.
+    //   This way, if a prop is read-only and cannot be edited in the UI, it can
+    //   still be removed.
+    return {
+        type: 'unserializable',
+        stringifiedData: stringifyUnserializableData(data),
+    };
+}
+function stringifyUnserializableData(data) {
+    // NOTE: We used to use the react-element-to-jsx-string package but it added
+    // bloat and complicated ESM support. We might go back to something similar
+    // in the future. Or expose a plugin API for custom stringifiers.
+    return isElement(data) ? '<React.Element />' : String(data);
+}

package/dist/fixtureState/extendWithValues.d.ts

@@ -0,0 +1,3 @@
+import { FixtureStateValue, FixtureStateValues, ObjectData } from './types.js';
+export declare function extendWithValues(obj: ObjectData, values: FixtureStateValues): ObjectData;
+export declare function extendWithValue(data: unknown, value: FixtureStateValue): unknown;

package/dist/fixtureState/extendWithValues.js

@@ -0,0 +1,22 @@
+import { isArray, isObject } from './shared.js';
+// Use fixture state for serializable values and fall back to base values
+export function extendWithValues(obj, values) {
+    const extendedObj = {};
+    Object.keys(values).forEach(key => {
+        extendedObj[key] = extendWithValue(obj[key], values[key]);
+    });
+    return extendedObj;
+}
+export function extendWithValue(data, value) {
+    if (value.type === 'unserializable')
+        return data;
+    if (value.type === 'object') {
+        const obj = isObject(data) ? data : {};
+        return extendWithValues(obj, value.values);
+    }
+    if (value.type === 'array') {
+        const array = isArray(data) ? data : [];
+        return value.values.map((v, idx) => extendWithValue(array[idx], v));
+    }
+    return value.data;
+}

package/dist/fixtureState/props.d.ts

@@ -0,0 +1,30 @@
+import { FixtureDecoratorId, FixtureElementId, FixtureRenderKey, FixtureState, FixtureStateProps, FixtureStateValues } from './types.js';
+export declare const DEFAULT_RENDER_KEY: FixtureRenderKey;
+export declare function getFixtureStateProps(fixtureState: FixtureState, decoratorId: FixtureDecoratorId): FixtureStateProps[];
+export declare function findFixtureStateProps(fixtureState: FixtureState, elementId: FixtureElementId): void | FixtureStateProps;
+type CreateFixtureStatePropsArgs = {
+    fixtureState: FixtureState;
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+    componentName: string;
+};
+export declare function createFixtureStateProps({ fixtureState, elementId, values, componentName, }: CreateFixtureStatePropsArgs): {
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+    renderKey: number;
+    componentName: string;
+}[];
+type ResetFixtureStatePropsArgs = {
+    fixtureState: FixtureState;
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+};
+export declare function resetFixtureStateProps({ fixtureState, elementId, values, }: ResetFixtureStatePropsArgs): FixtureStateProps[];
+type UpdateFixtureStatePropsArgs = {
+    fixtureState: FixtureState;
+    elementId: FixtureElementId;
+    values: FixtureStateValues;
+};
+export declare function updateFixtureStateProps({ fixtureState, elementId, values, }: UpdateFixtureStatePropsArgs): FixtureStateProps[];
+export declare function removeFixtureStateProps(fixtureState: FixtureState, elementId: FixtureElementId): FixtureStateProps[];
+export {};

package/dist/fixtureState/props.js

@@ -0,0 +1,49 @@
+import { find, isEqual } from 'lodash-es';
+import { removeItemMatch, replaceOrAddItem, updateItem, } from '../utils/array.js';
+export const DEFAULT_RENDER_KEY = 0;
+export function getFixtureStateProps(fixtureState, decoratorId) {
+    const { props } = fixtureState;
+    return props
+        ? props.filter(p => p.elementId.decoratorId === decoratorId)
+        : [];
+}
+export function findFixtureStateProps(fixtureState, elementId) {
+    const { props } = fixtureState;
+    return props && find(props, p => isEqual(p.elementId, elementId));
+}
+export function createFixtureStateProps({ fixtureState, elementId, values, componentName, }) {
+    const { props = [] } = fixtureState;
+    return replaceOrAddItem(props, createPropsMatcher(elementId), {
+        elementId,
+        values,
+        renderKey: DEFAULT_RENDER_KEY,
+        componentName,
+    });
+}
+export function resetFixtureStateProps({ fixtureState, elementId, values, }) {
+    const propsItem = expectFixtureStateProps(fixtureState, elementId);
+    return updateItem(fixtureState.props, propsItem, {
+        values,
+        renderKey: propsItem.renderKey + 1,
+    });
+}
+export function updateFixtureStateProps({ fixtureState, elementId, values, }) {
+    const propsItem = expectFixtureStateProps(fixtureState, elementId);
+    return updateItem(fixtureState.props, propsItem, {
+        values,
+    });
+}
+export function removeFixtureStateProps(fixtureState, elementId) {
+    return removeItemMatch(fixtureState.props || [], createPropsMatcher(elementId));
+}
+function createPropsMatcher(elementId) {
+    return (p) => isEqual(p.elementId, elementId);
+}
+function expectFixtureStateProps(fixtureState, elementId) {
+    const propsItem = findFixtureStateProps(fixtureState, elementId);
+    if (!propsItem) {
+        const elId = JSON.stringify(elementId);
+        throw new Error(`Fixture state props missing for element "${elId}"`);
+    }
+    return propsItem;
+}

package/dist/fixtureState/shared.d.ts

@@ -0,0 +1,9 @@
+import { ArrayData, ObjectData, PrimitiveData } from './types.js';
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isNull(value: unknown): value is null;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isPrimitiveData(data: unknown): data is PrimitiveData;
+export declare function isObject(data: unknown): data is ObjectData;
+export declare function isArray(data: unknown): data is ArrayData;

package/dist/fixtureState/shared.js

@@ -0,0 +1,30 @@
+import { isPlainObject } from 'lodash-es';
+import { isElement } from 'react-is';
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isNumber(value) {
+    return typeof value === 'number';
+}
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+export function isNull(value) {
+    return value === null;
+}
+export function isUndefined(value) {
+    return value === undefined;
+}
+export function isPrimitiveData(data) {
+    return (isString(data) ||
+        isNumber(data) ||
+        isBoolean(data) ||
+        isNull(data) ||
+        isUndefined(data));
+}
+export function isObject(data) {
+    return isPlainObject(data) && !isElement(data);
+}
+export function isArray(data) {
+    return Array.isArray(data);
+}