react-cosmos-ui 6.0.0-alpha.0

package/dist/slots/FixtureActionSlot.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ArraySlot } from 'react-plugin';
+export function FixtureActionSlot({ slotProps, plugOrder }) {
+    return (React.createElement(ArraySlot, { name: "fixtureAction", slotProps: slotProps, plugOrder: plugOrder }));
+}

package/dist/slots/NavRowSlot.d.ts

@@ -0,0 +1,9 @@
+export type NavRowSlotProps = {
+    onCloseNav: () => unknown;
+};
+type Props = {
+    slotProps: NavRowSlotProps;
+    plugOrder: string[];
+};
+export declare function NavRowSlot({ slotProps, plugOrder }: Props): JSX.Element;
+export {};

package/dist/slots/NavRowSlot.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ArraySlot } from 'react-plugin';
+export function NavRowSlot({ slotProps, plugOrder }) {
+    return (React.createElement(ArraySlot, { name: "navRow", slotProps: slotProps, plugOrder: plugOrder }));
+}

package/dist/slots/RendererActionSlot.d.ts

@@ -0,0 +1,10 @@
+import { FixtureId } from 'react-cosmos-core';
+export type RendererActionSlotProps = {
+    fixtureId: FixtureId;
+};
+type Props = {
+    slotProps: RendererActionSlotProps;
+    plugOrder: string[];
+};
+export declare function RendererActionSlot({ slotProps, plugOrder }: Props): JSX.Element;
+export {};

package/dist/slots/RendererActionSlot.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ArraySlot } from 'react-plugin';
+export function RendererActionSlot({ slotProps, plugOrder }) {
+    return (React.createElement(ArraySlot, { name: "rendererAction", slotProps: slotProps, plugOrder: plugOrder }));
+}

package/dist/slots/SidePanelRowSlot.d.ts

@@ -0,0 +1,12 @@
+import { FixtureId, FixtureState, StateUpdater } from 'react-cosmos-core';
+export type SidePanelRowSlotProps = {
+    fixtureId: FixtureId;
+    fixtureState: FixtureState;
+    onFixtureStateChange: (stateUpdater: StateUpdater<FixtureState>) => void;
+};
+type Props = {
+    slotProps: SidePanelRowSlotProps;
+    plugOrder: string[];
+};
+export declare function SidePanelRowSlot({ slotProps, plugOrder }: Props): JSX.Element;
+export {};

package/dist/slots/SidePanelRowSlot.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ArraySlot } from 'react-plugin';
+export function SidePanelRowSlot({ slotProps, plugOrder }) {
+    return (React.createElement(ArraySlot, { name: "sidePanelRow", slotProps: slotProps, plugOrder: plugOrder }));
+}

package/dist/slots/ValueInputSlot.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { FixtureStatePrimitiveValue, FixtureStateUnserializableValue, PrimitiveData } from 'react-cosmos-core';
+type LeafValue = FixtureStatePrimitiveValue | FixtureStateUnserializableValue;
+export type ValueInputSlotProps = {
+    id: string;
+    name: string;
+    value: LeafValue;
+    indentLevel: number;
+    onChange: (data: PrimitiveData) => unknown;
+};
+type Props = {
+    children: ReactNode;
+    slotProps: ValueInputSlotProps;
+};
+export declare function ValueInputSlot({ children, slotProps }: Props): JSX.Element;
+export {};

package/dist/slots/ValueInputSlot.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Slot } from 'react-plugin';
+export function ValueInputSlot({ children, slotProps }) {
+    return (React.createElement(Slot, { name: "valueInput", slotProps: slotProps }, children));
+}

package/dist/style/colors.d.ts

@@ -0,0 +1,37 @@
+export declare const grey8: string;
+export declare const grey24: string;
+export declare const grey32: string;
+export declare const grey64: string;
+export declare const grey96: string;
+export declare const grey128: string;
+export declare const grey160: string;
+export declare const grey144: string;
+export declare const grey176: string;
+export declare const grey192: string;
+export declare const grey208: string;
+export declare const grey216: string;
+export declare const grey224: string;
+export declare const grey248: string;
+export declare const black60: string;
+export declare const white3: string;
+export declare const white10: string;
+export declare const white20: string;
+export declare const white95: string;
+export declare const blue = "#3182ce";
+export declare const lightBlue = "#63b3ed";
+export declare const screenGrey1 = "hsl(230, 17%, 22%)";
+export declare const screenGrey2 = "hsl(230, 19%, 33%)";
+export declare const screenGrey3 = "hsl(230, 22%, 49%)";
+export declare const screenGrey4 = "hsl(230, 25%, 74%)";
+export declare const screenGrey5 = "hsl(230, 28%, 85%)";
+export declare const screenGrey6 = "hsl(230, 32%, 93%)";
+export declare const screenPrimary1 = "hsl(230, 48%, 32%)";
+export declare const screenPrimary2 = "hsl(230, 51%, 43%)";
+export declare const screenPrimary3 = "hsl(230, 65%, 61%)";
+export declare function selectedColors(defaultColor: string, selectedColor: string): (props: {
+    selected?: boolean;
+}) => string;
+export declare function disabledColors(defaultColor: string, disabledColor: string): (props: {
+    disabled?: boolean;
+}) => string;
+export declare function createGreyColor(intensity: number, alpha?: number): string;

package/dist/style/colors.js

@@ -0,0 +1,43 @@
+// Chrome colors (neutral)
+export const grey8 = createGreyColor(8);
+export const grey24 = createGreyColor(24);
+export const grey32 = createGreyColor(32);
+export const grey64 = createGreyColor(64);
+export const grey96 = createGreyColor(96);
+export const grey128 = createGreyColor(128);
+export const grey160 = createGreyColor(160);
+export const grey144 = createGreyColor(144);
+export const grey176 = createGreyColor(176);
+export const grey192 = createGreyColor(192);
+export const grey208 = createGreyColor(208);
+export const grey216 = createGreyColor(216);
+export const grey224 = createGreyColor(224);
+export const grey248 = createGreyColor(248);
+export const black60 = createGreyColor(0, 0.6);
+export const white3 = createGreyColor(255, 0.03);
+export const white10 = createGreyColor(255, 0.1);
+export const white20 = createGreyColor(255, 0.2);
+export const white95 = createGreyColor(255, 0.95);
+export const blue = '#3182ce';
+export const lightBlue = '#63b3ed';
+// Screen colors
+export const screenGrey1 = 'hsl(230, 17%, 22%)';
+export const screenGrey2 = 'hsl(230, 19%, 33%)';
+export const screenGrey3 = 'hsl(230, 22%, 49%)';
+export const screenGrey4 = 'hsl(230, 25%, 74%)';
+export const screenGrey5 = 'hsl(230, 28%, 85%)';
+export const screenGrey6 = 'hsl(230, 32%, 93%)';
+export const screenPrimary1 = 'hsl(230, 48%, 32%)';
+export const screenPrimary2 = 'hsl(230, 51%, 43%)';
+export const screenPrimary3 = 'hsl(230, 65%, 61%)';
+export function selectedColors(defaultColor, selectedColor) {
+    return (props) => props.selected ? selectedColor : defaultColor;
+}
+export function disabledColors(defaultColor, disabledColor) {
+    return (props) => props.disabled ? disabledColor : defaultColor;
+}
+export function createGreyColor(intensity, alpha = 1) {
+    return alpha !== 1
+        ? `rgba(${intensity}, ${intensity}, ${intensity}, ${alpha})`
+        : `rgb(${intensity}, ${intensity}, ${intensity})`;
+}

package/dist/style/globalStyle.d.ts

@@ -0,0 +1,2 @@
+export declare const GlobalStyle: import("styled-components").GlobalStyleComponent<{}, import("styled-components").DefaultTheme>;
+export declare const CosmosGlobalStyle: import("styled-components").GlobalStyleComponent<{}, import("styled-components").DefaultTheme>;

package/dist/style/globalStyle.js

@@ -0,0 +1,49 @@
+import { createGlobalStyle } from 'styled-components';
+import { grey8, white3 } from './colors.js';
+import { fontFamily } from './vars.js';
+export const GlobalStyle = createGlobalStyle `
+  html {
+    font-family: ${fontFamily};
+    font-size: 14px;
+    -webkit-font-smoothing: antialiased;
+  }
+
+  body, p, ul, ol, li, h1, h2, h3, button, input, textarea, select {
+    margin: 0;
+    padding: 0;
+  }
+
+  input, textarea, button {
+    font-family: ${fontFamily};
+  }
+
+  input, textarea, button {
+    font-size: 14px;
+  }
+
+  a {}
+`;
+export const CosmosGlobalStyle = createGlobalStyle `
+  body {
+    background-color: ${grey8};
+    /* Black checkerboard effect on background */
+    background-image: linear-gradient(
+        45deg,
+        ${white3} 25%,
+        transparent 25%,
+        transparent 75%,
+        ${white3} 75%,
+        ${white3} 100%
+      ),
+      linear-gradient(
+        45deg,
+        ${white3} 25%,
+        transparent 25%,
+        transparent 75%,
+        ${white3} 75%,
+        ${white3} 100%
+      );
+    background-size: 32px 32px;
+    background-position: 0 0, 16px 16px;
+  }
+`;

package/dist/style/vars.d.ts

@@ -0,0 +1,2 @@
+export declare const fontFamily = "-apple-system, BlinkMacSystemFont, Ubuntu, 'Helvetica Neue', Helvetica, sans-serif";
+export declare const quick = 0.32;

package/dist/style/vars.js

@@ -0,0 +1,2 @@
+export const fontFamily = `-apple-system, BlinkMacSystemFont, Ubuntu, 'Helvetica Neue', Helvetica, sans-serif`;
+export const quick = 0.32;

package/dist/testHelpers/pluginHelpers.d.ts

@@ -0,0 +1,5 @@
+import { PlugComponentType, PluginEventHandlers, PluginMethodHandlers, PluginSpec, PluginWithEvents, PluginWithMethods } from 'react-plugin';
+export declare function getMethodsOf<Spec extends PluginSpec>(pluginName: Spec['name']): Spec["methods"] extends import("ui-plugin/dist/types/PluginSpec").PluginMethods ? Spec["methods"] : never;
+export declare function on<Spec extends PluginWithEvents>(pluginName: Spec['name'], handlers: PluginEventHandlers<any, Spec>): void;
+export declare function mockMethodsOf<Spec extends PluginWithMethods>(pluginName: Spec['name'], methods: PluginMethodHandlers<Spec>): void;
+export declare function mockPlug<SlotProps extends {} = {}>(slotName: string, component: PlugComponentType<any, any>): void;

package/dist/testHelpers/pluginHelpers.js

@@ -0,0 +1,25 @@
+import { createPlugin, getPluginContext, } from 'react-plugin';
+export function getMethodsOf(pluginName) {
+    const name = getNewPluginName();
+    createPlugin({ name }).register();
+    return getPluginContext(name).getMethodsOf(pluginName);
+}
+export function on(pluginName, handlers) {
+    const name = getNewPluginName();
+    const testPlugin = createPlugin({ name });
+    testPlugin.on(pluginName, handlers);
+    testPlugin.register();
+}
+export function mockMethodsOf(pluginName, methods) {
+    createPlugin({ name: pluginName, methods }).register();
+}
+export function mockPlug(slotName, component) {
+    const name = getNewPluginName();
+    const testPlugin = createPlugin({ name });
+    testPlugin.plug(slotName, component);
+    testPlugin.register();
+}
+let pluginId = 0;
+function getNewPluginName() {
+    return `test${pluginId++}`;
+}

package/dist/testHelpers/pluginMocks.d.ts

@@ -0,0 +1,116 @@
+/// <reference types="jest" />
+import { PluginEventHandlers, PluginMethodHandlers, PluginWithEvents, PluginWithMethods } from 'react-plugin';
+import { CoreSpec } from '../plugins/Core/spec.js';
+import { FixtureTreeSpec } from '../plugins/FixtureTree/spec.js';
+import { MessageHandlerSpec } from '../plugins/MessageHandler/spec.js';
+import { NotificationsSpec } from '../plugins/Notifications/spec.js';
+import { RendererCoreSpec } from '../plugins/RendererCore/spec.js';
+import { RendererPreviewSpec } from '../plugins/RendererPreview/spec.js';
+import { RouterSpec } from '../plugins/Router/spec.js';
+import { StorageSpec } from '../plugins/Storage/spec.js';
+type MethodsOf<Spec extends PluginWithMethods> = Partial<PluginMethodHandlers<Spec>>;
+type EventsOf<Spec extends PluginWithEvents> = PluginEventHandlers<any, Spec>;
+export declare function getRouterContext(): import("react-plugin").PluginContext<RouterSpec>;
+export declare function getMessageHandlerContext(): import("react-plugin").PluginContext<MessageHandlerSpec>;
+export declare function getRendererCoreContext(): import("react-plugin").PluginContext<RendererCoreSpec>;
+export declare function getRouterMethods(): {
+    getSelectedFixtureId(): import("react-cosmos-core").FixtureId | null;
+    selectFixture(fixtureId: import("react-cosmos-core").FixtureId): void;
+    unselectFixture(): void;
+};
+export declare function getMessageHandlerMethods(): {
+    postRendererRequest(msg: import("react-cosmos-core").MessageType): unknown;
+};
+export declare function getCoreMethods(): {
+    registerCommands(commands: import("../plugins/Core/spec.js").Commands): () => void;
+    runCommand(name: string): unknown;
+    getProjectId(): string;
+    getFixtureFileVars(): {
+        fixturesDir: string;
+        fixtureFileSuffix: string;
+    };
+    isDevServerOn(): boolean;
+    getWebRendererUrl(): string | null;
+};
+export declare function getRendererCoreMethods(): {
+    getConnectedRendererIds(): string[];
+    getPrimaryRendererId(): string | null;
+    getFixtures(): import("react-cosmos-core").FixtureList;
+    getFixtureState(): import("react-cosmos-core").FixtureState;
+    isRendererConnected(): boolean;
+    isValidFixtureSelected(): boolean;
+    setFixtureState(stateUpdater: import("react-cosmos-core").StateUpdater<import("react-cosmos-core").FixtureState>): void;
+    selectPrimaryRenderer(primaryRendererId: string): void;
+    receiveResponse(msg: import("react-cosmos-core").MessageType): void;
+};
+export declare function getNotificationsMethods(): {
+    pushStickyNotification(notification: import("../plugins/Notifications/spec.js").NotificationItem): void;
+    removeStickyNotification(notificationId: string): void;
+    pushTimedNotification(notification: import("../plugins/Notifications/spec.js").NotificationItem): void;
+};
+export declare function getRendererPreviewMethods(): {
+    getUrlStatus(): import("../plugins/RendererPreview/spec.js").UrlStatus;
+    getRuntimeStatus(): import("../plugins/RendererPreview/spec.js").RuntimeStatus;
+};
+export declare function mockStorage(methods?: MethodsOf<StorageSpec>): {
+    loadCache: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<StorageSpec>, projectId: string) => Promise<unknown>);
+    getItem: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<StorageSpec>, key: string) => unknown);
+    setItem: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<StorageSpec>, key: string, value: unknown) => void);
+};
+export declare function mockRouter(methods?: MethodsOf<RouterSpec>): {
+    getSelectedFixtureId: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RouterSpec>) => import("react-cosmos-core").FixtureId | null);
+    selectFixture: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RouterSpec>, fixtureId: import("react-cosmos-core").FixtureId) => void);
+    unselectFixture: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RouterSpec>) => void);
+};
+export declare function mockCore(methods?: MethodsOf<CoreSpec>): {
+    registerCommands: (() => jest.Mock<any, any, any>) | ((context: import("react-plugin").PluginContext<CoreSpec>, commands: import("../plugins/Core/spec.js").Commands) => () => void);
+    runCommand: (context: import("react-plugin").PluginContext<CoreSpec>, name: string) => unknown;
+    getProjectId: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<CoreSpec>) => string);
+    getFixtureFileVars: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<CoreSpec>) => {
+        fixturesDir: string;
+        fixtureFileSuffix: string;
+    });
+    isDevServerOn: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<CoreSpec>) => boolean);
+    getWebRendererUrl: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<CoreSpec>) => string | null);
+};
+export declare function mockMessageHandler(methods?: MethodsOf<MessageHandlerSpec>): {
+    postRendererRequest: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<MessageHandlerSpec>, msg: import("react-cosmos-core").MessageType) => unknown);
+};
+export declare function mockRendererCore(methods?: MethodsOf<RendererCoreSpec>): {
+    getConnectedRendererIds: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => string[]);
+    getPrimaryRendererId: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => string | null);
+    getFixtures: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => import("react-cosmos-core").FixtureList);
+    getFixtureState: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => import("react-cosmos-core").FixtureState);
+    isRendererConnected: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => boolean);
+    isValidFixtureSelected: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>) => boolean);
+    setFixtureState: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>, stateUpdater: import("react-cosmos-core").StateUpdater<import("react-cosmos-core").FixtureState>) => void);
+    selectPrimaryRenderer: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>, primaryRendererId: string) => void);
+    receiveResponse: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererCoreSpec>, msg: import("react-cosmos-core").MessageType) => void);
+};
+export declare function mockRendererPreview(methods?: MethodsOf<RendererPreviewSpec>): {
+    getUrlStatus: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererPreviewSpec>) => import("../plugins/RendererPreview/spec.js").UrlStatus);
+    getRuntimeStatus: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<RendererPreviewSpec>) => import("../plugins/RendererPreview/spec.js").RuntimeStatus);
+};
+export declare function mockNotifications(methods?: MethodsOf<NotificationsSpec>): {
+    pushStickyNotification: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<NotificationsSpec>, notification: import("../plugins/Notifications/spec.js").NotificationItem) => void);
+    removeStickyNotification: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<NotificationsSpec>, notificationId: string) => void);
+    pushTimedNotification: jest.Mock<any, any, any> | ((context: import("react-plugin").PluginContext<NotificationsSpec>, notification: import("../plugins/Notifications/spec.js").NotificationItem) => void);
+};
+export declare function mockFixtureTree(methods?: MethodsOf<FixtureTreeSpec>): {
+    revealFixture: jest.Mock<any, any, any> | ((context: {
+        pluginName: "fixtureTree";
+        getMethodsOf: <T extends import("react-plugin").PluginSpec>(pluginName: T["name"]) => T["methods"] extends import("ui-plugin/dist/types/PluginSpec.js").PluginMethods ? T["methods"] : never;
+    }, fixtureId: import("react-cosmos-core").FixtureId) => unknown);
+};
+export declare function onRouter(events?: EventsOf<RouterSpec>): {
+    fixtureChange: jest.Mock<any, any, any> | import("ui-plugin/dist/types/PluginContextHandlers.js").PluginEventHandler<any, [fixtureId: import("react-cosmos-core").FixtureId | null]>;
+};
+export declare function onMessageHandler(events?: EventsOf<MessageHandlerSpec>): {
+    serverMessage: jest.Mock<any, any, any> | import("ui-plugin/dist/types/PluginContextHandlers.js").PluginEventHandler<any, [msg: import("react-cosmos-core").MessageType]>;
+    rendererResponse: jest.Mock<any, any, any> | import("ui-plugin/dist/types/PluginContextHandlers.js").PluginEventHandler<any, [msg: import("react-cosmos-core").MessageType]>;
+};
+export declare function onRendererCore(events?: EventsOf<RendererCoreSpec>): {
+    request: jest.Mock<any, any, any> | import("ui-plugin/dist/types/PluginContextHandlers.js").PluginEventHandler<any, [msg: import("react-cosmos-core").MessageType]>;
+    response: jest.Mock<any, any, any> | import("ui-plugin/dist/types/PluginContextHandlers.js").PluginEventHandler<any, [msg: import("react-cosmos-core").MessageType]>;
+};
+export {};

package/dist/testHelpers/pluginMocks.js

@@ -0,0 +1,139 @@
+import { getPluginContext, } from 'react-plugin';
+import { getMethodsOf, mockMethodsOf, on } from './pluginHelpers.js';
+export function getRouterContext() {
+    return getPluginContext('router');
+}
+export function getMessageHandlerContext() {
+    return getPluginContext('messageHandler');
+}
+export function getRendererCoreContext() {
+    return getPluginContext('rendererCore');
+}
+export function getRouterMethods() {
+    return getMethodsOf('router');
+}
+export function getMessageHandlerMethods() {
+    return getMethodsOf('messageHandler');
+}
+export function getCoreMethods() {
+    return getMethodsOf('core');
+}
+export function getRendererCoreMethods() {
+    return getMethodsOf('rendererCore');
+}
+export function getNotificationsMethods() {
+    return getMethodsOf('notifications');
+}
+export function getRendererPreviewMethods() {
+    return getMethodsOf('rendererPreview');
+}
+export function mockStorage(methods = {}) {
+    const allMethods = {
+        loadCache: jest.fn(),
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('storage', allMethods);
+    return allMethods;
+}
+export function mockRouter(methods = {}) {
+    const allMethods = {
+        getSelectedFixtureId: jest.fn(),
+        selectFixture: jest.fn(),
+        unselectFixture: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('router', allMethods);
+    return allMethods;
+}
+export function mockCore(methods = {}) {
+    const allMethods = {
+        registerCommands: () => jest.fn(),
+        runCommand: () => jest.fn(),
+        getProjectId: jest.fn(),
+        getFixtureFileVars: jest.fn(),
+        isDevServerOn: jest.fn(),
+        getWebRendererUrl: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('core', allMethods);
+    return allMethods;
+}
+export function mockMessageHandler(methods = {}) {
+    const allMethods = {
+        postRendererRequest: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('messageHandler', allMethods);
+    return allMethods;
+}
+export function mockRendererCore(methods = {}) {
+    const allMethods = {
+        getConnectedRendererIds: jest.fn(),
+        getPrimaryRendererId: jest.fn(),
+        getFixtures: jest.fn(),
+        getFixtureState: jest.fn(),
+        isRendererConnected: jest.fn(),
+        isValidFixtureSelected: jest.fn(),
+        setFixtureState: jest.fn(),
+        selectPrimaryRenderer: jest.fn(),
+        receiveResponse: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('rendererCore', allMethods);
+    return allMethods;
+}
+export function mockRendererPreview(methods = {}) {
+    const allMethods = {
+        getUrlStatus: jest.fn(),
+        getRuntimeStatus: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('rendererPreview', allMethods);
+    return allMethods;
+}
+export function mockNotifications(methods = {}) {
+    const allMethods = {
+        pushStickyNotification: jest.fn(),
+        removeStickyNotification: jest.fn(),
+        pushTimedNotification: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('notifications', allMethods);
+    return allMethods;
+}
+export function mockFixtureTree(methods = {}) {
+    const allMethods = {
+        revealFixture: jest.fn(),
+        ...methods,
+    };
+    mockMethodsOf('fixtureTree', allMethods);
+    return allMethods;
+}
+export function onRouter(events = {}) {
+    const allEvents = {
+        fixtureChange: jest.fn(),
+        ...events,
+    };
+    on('router', allEvents);
+    return allEvents;
+}
+export function onMessageHandler(events = {}) {
+    const allEvents = {
+        serverMessage: jest.fn(),
+        rendererResponse: jest.fn(),
+        ...events,
+    };
+    on('messageHandler', allEvents);
+    return allEvents;
+}
+export function onRendererCore(events = {}) {
+    const allEvents = {
+        request: jest.fn(),
+        response: jest.fn(),
+        ...events,
+    };
+    on('rendererCore', allEvents);
+    return allEvents;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "react-cosmos-ui",
+  "version": "6.0.0-alpha.0",
+  "description": "React Cosmos UI",
+  "repository": "https://github.com/react-cosmos/react-cosmos/tree/main/packages/react-cosmos-ui",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "sideEffects": [
+    "./dist/plugins/pluginEntry.js",
+    "./dist/plugins/*/index.js"
+  ],
+  "dependencies": {
+    "lodash-es": "^4.17.21",
+    "react-cosmos-core": "^6.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "fuzzaldrin-plus": "^0.6.0",
+    "localforage": "^1.10.0",
+    "react-plugin": "^3.0.0-alpha.4",
+    "styled-components": "^5.3.6"
+  },
+  "gitHead": "b021231584639f3028fe08deacd418f0ec4cc002"
+}