react-cosmos-core 6.0.0-alpha.0

package/dist/renderer/FixtureLoader/FixtureLoader.js

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

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

@@ -0,0 +1,18 @@
+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/FixtureLoader/fixtureHelpers.d.ts

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

package/dist/renderer/FixtureLoader/fixtureHelpers.js

@@ -0,0 +1,15 @@
+import { isMultiFixture } from '../isMultiFixture.js';
+export function getFixture(fixtureExport, fixtureName) {
+    if (fixtureName === undefined) {
+        if (isMultiFixture(fixtureExport)) {
+            // Fixture name missing in multi fixture
+            return;
+        }
+        return fixtureExport;
+    }
+    if (!isMultiFixture(fixtureExport)) {
+        // Fixture name not found in single fixture
+        return;
+    }
+    return fixtureExport[fixtureName];
+}

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

@@ -0,0 +1,9 @@
+import React from 'react';
+type Props = {
+    Component: React.FunctionComponent;
+};
+export declare function FixtureElement({ Component }: Props): JSX.Element;
+export declare namespace FixtureElement {
+    var cosmosCapture: boolean;
+}
+export {};

package/dist/renderer/FixtureLoader/getDecoratedFixtureElement/FixtureElement.js

@@ -0,0 +1,5 @@
+import React from 'react';
+export function FixtureElement({ Component }) {
+    return React.createElement(Component, null);
+}
+FixtureElement.cosmosCapture = false;

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

@@ -0,0 +1,2 @@
+import { ReactDecorator, ReactDecoratorProps, ReactFixture } from '../../reactTypes.js';
+export declare function getDecoratedFixtureElement(fixture: ReactFixture, decorators: ReactDecorator[], decoratorProps: Omit<ReactDecoratorProps, 'children'>): JSX.Element;

package/dist/renderer/FixtureLoader/getDecoratedFixtureElement/index.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import { FixtureCapture } from '../FixtureCapture/index.js';
+import { FixtureElement } from './FixtureElement.js';
+export function getDecoratedFixtureElement(fixture, decorators, decoratorProps) {
+    const fixtureElement = (React.createElement(FixtureCapture, { decoratorId: "root" }, getFixtureElement(fixture)));
+    return [...decorators]
+        .reverse()
+        .reduce((prevElement, Decorator) => (React.createElement(Decorator, { ...decoratorProps }, prevElement)), fixtureElement);
+}
+function getFixtureElement(fixture) {
+    return isFunctionFixture(fixture) ? (React.createElement(FixtureElement, { Component: fixture })) : (fixture);
+}
+function isFunctionFixture(fixture) {
+    return typeof fixture === 'function';
+}

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

@@ -0,0 +1,2 @@
+import { RendererConnect } from '../types.js';
+export declare function createPostMessageConnect(): RendererConnect;

package/dist/renderer/FixtureLoader/postMessage.js

@@ -0,0 +1,22 @@
+import { registerPlaygroundShortcuts } from '../registerPlaygroundShortcuts.js';
+export function createPostMessageConnect() {
+    function postMessage(msg) {
+        parent.postMessage(msg, '*');
+    }
+    return {
+        postMessage,
+        onMessage(onMessage) {
+            function handleMessage(msg) {
+                onMessage(msg.data);
+            }
+            window.addEventListener('message', handleMessage, false);
+            const removeShortcuts = registerPlaygroundShortcuts(command => {
+                postMessage({ type: 'playgroundCommand', payload: { command } });
+            });
+            return () => {
+                window.removeEventListener('message', handleMessage);
+                removeShortcuts();
+            };
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import { RendererConnect } from '../types.js';
+export declare function createWebSocketsConnect(url: string): RendererConnect;

package/dist/renderer/FixtureLoader/webSockets.js

@@ -0,0 +1,32 @@
+import { rendererSocketMessage, } from '../../server/socketMessage.js';
+export function createWebSocketsConnect(url) {
+    let pendingMessages = [];
+    const socket = new WebSocket(url);
+    socket.addEventListener('open', () => {
+        if (pendingMessages.length > 0) {
+            pendingMessages.forEach(msg => socket.send(JSON.stringify(msg)));
+            pendingMessages = [];
+        }
+    });
+    return {
+        postMessage(rendererResponse) {
+            const socketMessage = rendererSocketMessage(rendererResponse);
+            if (socket && socket.readyState === WebSocket.OPEN) {
+                socket.send(JSON.stringify(socketMessage));
+            }
+            else {
+                pendingMessages.push(socketMessage);
+            }
+        },
+        onMessage(onMessage) {
+            function handleMessage(msg) {
+                const socketMessage = JSON.parse(msg.data);
+                if (socketMessage.channel === 'renderer') {
+                    onMessage(socketMessage.message);
+                }
+            }
+            socket.addEventListener('message', handleMessage);
+            return () => socket.removeEventListener('message', handleMessage);
+        },
+    };
+}

package/dist/renderer/getFixtureList.d.ts

@@ -0,0 +1,8 @@
+import { FixtureListItem } from '../fixture/types.js';
+import { ReactFixtureExports, ReactFixtureWrappers } from './reactTypes.js';
+export declare function getFixtureListFromWrappers(wrappers: ReactFixtureWrappers): {
+    [x: string]: FixtureListItem;
+};
+export declare function getFixtureListFromExports(exports: ReactFixtureExports): {
+    [x: string]: FixtureListItem;
+};

package/dist/renderer/getFixtureList.js

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

package/dist/renderer/getSortedDecoratorsForFixturePath.d.ts

@@ -0,0 +1,2 @@
+import { ReactDecorator, ReactDecorators } from './reactTypes.js';
+export declare function getSortedDecoratorsForFixturePath(fixturePath: string, decoratorsByPath: ReactDecorators): ReactDecorator[];

package/dist/renderer/getSortedDecoratorsForFixturePath.js

@@ -0,0 +1,25 @@
+export function getSortedDecoratorsForFixturePath(fixturePath, decoratorsByPath) {
+    return getSortedDecorators(getDecoratorsForFixturePath(decoratorsByPath, fixturePath));
+}
+function getDecoratorsForFixturePath(decoratorsByPath, fixturePath) {
+    return Object.keys(decoratorsByPath)
+        .filter(dPath => isParentDir(getParentPath(dPath), fixturePath))
+        .reduce((acc, dPath) => ({ ...acc, [dPath]: decoratorsByPath[dPath] }), {});
+}
+function isParentDir(parentPath, filePath) {
+    return parentPath === '' || filePath.indexOf(`${parentPath}/`) === 0;
+}
+function getParentPath(nestedPath) {
+    // Remove everything right of the right-most forward slash, or return an
+    // empty string if path has no forward slash
+    return nestedPath.replace(/^((.+)\/)?.+$/, '$2');
+}
+function getSortedDecorators(decoratorsByPath) {
+    return sortPathsByDepthAsc(Object.keys(decoratorsByPath)).map(decoratorPath => decoratorsByPath[decoratorPath]);
+}
+function sortPathsByDepthAsc(paths) {
+    return [...paths].sort((a, b) => getPathNestingLevel(a) - getPathNestingLevel(b) || a.localeCompare(b));
+}
+function getPathNestingLevel(path) {
+    return path.split('/').length;
+}

package/dist/renderer/isMultiFixture.d.ts

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

package/dist/renderer/isMultiFixture.js

@@ -0,0 +1,6 @@
+import { isElement } from 'react-is';
+export function isMultiFixture(fixtureExport) {
+    return (fixtureExport !== null &&
+        typeof fixtureExport === 'object' &&
+        !isElement(fixtureExport));
+}

package/dist/renderer/reactTypes.d.ts

@@ -0,0 +1,28 @@
+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 {};

package/dist/renderer/reactTypes.js

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

package/dist/renderer/registerPlaygroundShortcuts.d.ts

@@ -0,0 +1 @@
+export declare function registerPlaygroundShortcuts(runCommand: (command: string) => unknown): () => void;

package/dist/renderer/registerPlaygroundShortcuts.js

@@ -0,0 +1,40 @@
+export function registerPlaygroundShortcuts(runCommand) {
+    window.addEventListener('keydown', handleWindowKeyDown);
+    function run(e, command) {
+        e.preventDefault();
+        runCommand(command);
+    }
+    function handleWindowKeyDown(e) {
+        if (isEditing()) {
+            return;
+        }
+        const keyChar = String.fromCharCode(e.keyCode);
+        const metaKey = e.metaKey || e.ctrlKey;
+        if (keyChar === 'P' && metaKey) {
+            run(e, 'searchFixtures');
+        }
+        else if (keyChar === 'L' && metaKey && e.shiftKey) {
+            run(e, 'toggleFixtureList');
+        }
+        else if (keyChar === 'K' && metaKey && e.shiftKey) {
+            run(e, 'toggleControlPanel');
+        }
+        else if (keyChar === 'F' && metaKey && e.shiftKey) {
+            run(e, 'goFullScreen');
+        }
+        else if (keyChar === 'E' && metaKey && e.shiftKey) {
+            run(e, 'editFixture');
+        }
+    }
+    return () => {
+        window.removeEventListener('keydown', handleWindowKeyDown);
+    };
+}
+function isEditing() {
+    const activeElement = document.activeElement;
+    return activeElement && isInputTag(activeElement.tagName);
+}
+function isInputTag(tagName) {
+    const inputTags = ['input', 'textarea', 'select'];
+    return inputTags.includes(tagName.toLowerCase());
+}

package/dist/renderer/rendererConfig.d.ts

@@ -0,0 +1,3 @@
+export type RendererConfig = {
+    playgroundUrl: string;
+};

package/dist/renderer/rendererConfig.js

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

package/dist/renderer/types.d.ts

@@ -0,0 +1,69 @@
+import { FixtureState } from '../fixtureState/types.js';
+import { FixtureId, FixtureList } from '../fixture/types.js';
+export type RendererId = string;
+export type PingRenderersRequest = {
+    type: 'pingRenderers';
+};
+export type SelectFixtureRequest = {
+    type: 'selectFixture';
+    payload: {
+        rendererId: RendererId;
+        fixtureId: FixtureId;
+        fixtureState: FixtureState;
+    };
+};
+export type UnselectFixtureRequest = {
+    type: 'unselectFixture';
+    payload: {
+        rendererId: RendererId;
+    };
+};
+export type SetFixtureStateRequest = {
+    type: 'setFixtureState';
+    payload: {
+        rendererId: RendererId;
+        fixtureId: FixtureId;
+        fixtureState: FixtureState;
+    };
+};
+export type RendererRequest = PingRenderersRequest | SelectFixtureRequest | UnselectFixtureRequest | SetFixtureStateRequest;
+export type RendererReadyResponse = {
+    type: 'rendererReady';
+    payload: {
+        rendererId: RendererId;
+        fixtures: FixtureList;
+        initialFixtureId?: FixtureId;
+    };
+};
+export type RendererErrorResponse = {
+    type: 'rendererError';
+    payload: {
+        rendererId: RendererId;
+    };
+};
+export type FixtureListUpdateResponse = {
+    type: 'fixtureListUpdate';
+    payload: {
+        rendererId: RendererId;
+        fixtures: FixtureList;
+    };
+};
+export type FixtureStateChangeResponse = {
+    type: 'fixtureStateChange';
+    payload: {
+        rendererId: RendererId;
+        fixtureId: FixtureId;
+        fixtureState: FixtureState;
+    };
+};
+export type PlaygroundCommandResponse = {
+    type: 'playgroundCommand';
+    payload: {
+        command: string;
+    };
+};
+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;
+};

package/dist/renderer/types.js

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

package/dist/server/cosmosPluginConfig.d.ts

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

package/dist/server/cosmosPluginConfig.js

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

package/dist/server/serverMessage.d.ts

@@ -0,0 +1,10 @@
+export type BuildStartMessage = {
+    type: 'buildStart';
+};
+export type BuildErrorMessage = {
+    type: 'buildError';
+};
+export type BuildDoneMessage = {
+    type: 'buildDone';
+};
+export type ServerMessage = BuildStartMessage | BuildErrorMessage | BuildDoneMessage;

package/dist/server/serverMessage.js

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