react-cosmos 6.0.0-alpha.8 → 6.0.0-beta.0

package/dist/{server/devServer → devServer}/expressApp.js

@@ -2,9 +2,9 @@ import express from 'express';
 import { getDevPlaygroundHtml } from '../shared/playgroundHtml.js';
 import { getStaticPath } from '../shared/staticPath.js';
 import { resolve } from '../utils/resolve.js';
-export async function createExpressApp(platformType, cosmosConfig, pluginConfigs) {
+export async function createExpressApp(platform, cosmosConfig, pluginConfigs) {
     const app = express();
-    const playgroundHtml = await getDevPlaygroundHtml(platformType, cosmosConfig, pluginConfigs);
+    const playgroundHtml = await getDevPlaygroundHtml(platform, cosmosConfig, pluginConfigs);
     app.get('/', (req, res) => {
         res.send(playgroundHtml);
     });

package/dist/{server/devServer → devServer}/messageHandler.d.ts

@@ -3,5 +3,5 @@ import http from 'http';
 import { ServerMessage } from 'react-cosmos-core';
 export declare function createMessageHandler(httpServer: http.Server): {
     sendMessage: (msg: ServerMessage) => void;
-    cleanUp: () => void;
+    close: () => void;
 };

package/dist/{server/devServer → devServer}/messageHandler.js

@@ -21,9 +21,9 @@ export function createMessageHandler(httpServer) {
             }
         });
     }
-    function cleanUp() {
+    function close() {
         wss.clients.forEach(client => client.close());
         wss.close();
     }
-    return { sendMessage, cleanUp };
+    return { sendMessage, close };
 }

package/dist/devServer/startDevServer.d.ts

@@ -0,0 +1,2 @@
+import { CosmosPlatform } from '../cosmosPlugin/types.js';
+export declare function startDevServer(platform: CosmosPlatform): Promise<() => Promise<void>>;

package/dist/{server/devServer → devServer}/startDevServer.js

@@ -1,24 +1,15 @@
 import path from 'path';
 import { detectCosmosConfig, detectCosmosConfigPath, } from '../cosmosConfig/detectCosmosConfig.js';
 import { getPluginConfigs } from '../cosmosPlugin/pluginConfigs.js';
+import { applyServerConfigPlugins } from '../shared/applyServerConfigPlugins.js';
+import { getServerPlugins } from '../shared/getServerPlugins.js';
 import { logPluginInfo } from '../shared/logPluginInfo.js';
-import { requirePluginModule } from '../shared/requirePluginModule.js';
 import { serveStaticDir } from '../shared/staticServer.js';
-import { httpProxyDevServerPlugin } from './corePlugins/httpProxy.js';
-import openFileDevServerPlugin from './corePlugins/openFile.js';
-import pluginEndpointDevServerPlugin from './corePlugins/pluginEndpoint.js';
-import { userDepsFileDevServerPlugin } from './corePlugins/userDepsFile.js';
 import { createExpressApp } from './expressApp.js';
 import { createHttpServer } from './httpServer.js';
 import { createMessageHandler } from './messageHandler.js';
-const builtInPlugins = [
-    userDepsFileDevServerPlugin,
-    httpProxyDevServerPlugin,
-    openFileDevServerPlugin,
-    pluginEndpointDevServerPlugin,
-];
-export async function startDevServer(platformType) {
-    const cosmosConfig = await detectCosmosConfig();
+export async function startDevServer(platform) {
+    let cosmosConfig = await detectCosmosConfig();
     logCosmosConfigInfo();
     const pluginConfigs = await getPluginConfigs({
         cosmosConfig,
@@ -28,24 +19,35 @@ export async function startDevServer(platformType) {
         relativePaths: false,
     });
     logPluginInfo(pluginConfigs);
-    const app = await createExpressApp(platformType, cosmosConfig, pluginConfigs);
+    const serverPlugins = await getServerPlugins(pluginConfigs, cosmosConfig.rootDir);
+    cosmosConfig = await applyServerConfigPlugins({
+        cosmosConfig,
+        serverPlugins,
+        command: 'dev',
+        platform,
+    });
+    const app = await createExpressApp(platform, cosmosConfig, pluginConfigs);
     const httpServer = await createHttpServer(cosmosConfig, app);
     const msgHandler = createMessageHandler(httpServer.server);
+    if (cosmosConfig.staticPath) {
+        serveStaticDir(app, cosmosConfig.staticPath, cosmosConfig.publicUrl);
+    }
     // Make Playground available as soon as possible and show a loading screen
     // while plugins are initializing
     await httpServer.start();
     const pluginCleanupCallbacks = [];
     async function cleanUp() {
         await Promise.all(pluginCleanupCallbacks.map(cleanup => cleanup()));
+        msgHandler.close();
         await httpServer.stop();
-        msgHandler.cleanUp();
     }
-    const userPlugins = await getDevServerPlugins(pluginConfigs, cosmosConfig.rootDir);
-    for (const plugin of [...builtInPlugins, ...userPlugins]) {
+    for (const plugin of serverPlugins) {
         try {
-            const pluginReturn = await plugin({
+            if (!plugin.devServer)
+                continue;
+            const pluginReturn = await plugin.devServer({
                 cosmosConfig,
-                platformType,
+                platform,
                 httpServer: httpServer.server,
                 expressApp: app,
                 sendMessage: msgHandler.sendMessage,
@@ -58,7 +60,7 @@ export async function startDevServer(platformType) {
                     catch (err) {
                         // Log when a plugin fails to clean up, but continue to attempt
                         // to clean up the remaining plugins
-                        console.log(`[Cosmos][${plugin.name}] Dev server plugin cleanup failed`);
+                        console.log(`[Cosmos][plugin:${plugin.name}] Dev server cleanup failed`);
                         console.log(err);
                     }
                 });
@@ -67,14 +69,11 @@ export async function startDevServer(platformType) {
         catch (err) {
             // Abort starting server if a plugin init fails and attempt cleanup of all
             // plugins that have already initialized
-            console.log(`[Cosmos][${plugin.name}] Dev server plugin init failed`);
+            console.log(`[Cosmos][plugin:${plugin.name}] Dev server init failed`);
             cleanUp();
             throw err;
         }
     }
-    if (cosmosConfig.staticPath) {
-        serveStaticDir(app, cosmosConfig.staticPath, cosmosConfig.publicUrl);
-    }
     return cleanUp;
 }
 function logCosmosConfigInfo() {
@@ -86,8 +85,3 @@ function logCosmosConfigInfo() {
     const relConfigPath = path.relative(process.cwd(), cosmosConfigPath);
     console.log(`[Cosmos] Using cosmos config found at ${relConfigPath}`);
 }
-async function getDevServerPlugins(pluginConfigs, rootDir) {
-    return Promise.all(pluginConfigs
-        .filter(pluginConfig => pluginConfig.devServer)
-        .map(pluginConfig => requirePluginModule(rootDir, pluginConfig, 'devServer')));
-}

package/dist/{server/export → export}/generateExport.js

@@ -1,16 +1,15 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { removeLeadingSlash, } from 'react-cosmos-core';
 import { detectCosmosConfig } from '../cosmosConfig/detectCosmosConfig.js';
 import { getPluginConfigs } from '../cosmosPlugin/pluginConfigs.js';
+import { applyServerConfigPlugins } from '../shared/applyServerConfigPlugins.js';
+import { getServerPlugins } from '../shared/getServerPlugins.js';
 import { logPluginInfo } from '../shared/logPluginInfo.js';
 import { getExportPlaygroundHtml } from '../shared/playgroundHtml.js';
-import { requirePluginModule } from '../shared/requirePluginModule.js';
 import { getStaticPath } from '../shared/staticPath.js';
 import { resolve } from '../utils/resolve.js';
-const builtInPlugins = [];
 export async function generateExport() {
-    const cosmosConfig = await detectCosmosConfig();
+    let cosmosConfig = await detectCosmosConfig();
     const pluginConfigs = await getPluginConfigs({
         cosmosConfig,
         // Relative paths work in exports because all plugin modules are copied
@@ -18,19 +17,28 @@ export async function generateExport() {
         relativePaths: true,
     });
     logPluginInfo(pluginConfigs);
+    const serverPlugins = await getServerPlugins(pluginConfigs, cosmosConfig.rootDir);
+    cosmosConfig = await applyServerConfigPlugins({
+        cosmosConfig,
+        serverPlugins,
+        command: 'export',
+        platform: 'web',
+    });
     // Clear previous export (or other files at export path)
     const { exportPath } = cosmosConfig;
     await fs.rm(exportPath, { recursive: true, force: true });
+    await fs.mkdir(exportPath, { recursive: true });
     // Copy static assets first, so that the built index.html overrides the its
     // template file (in case the static assets are served from the root path)
     await copyStaticAssets(cosmosConfig);
-    const userPlugins = await getExportPlugins(pluginConfigs, cosmosConfig.rootDir);
-    for (const plugin of [...builtInPlugins, ...userPlugins]) {
+    for (const plugin of serverPlugins) {
+        if (!plugin.export)
+            continue;
         try {
-            await plugin({ cosmosConfig });
+            await plugin.export({ cosmosConfig });
         }
         catch (err) {
-            console.log(`[Cosmos][${plugin.name}] Export plugin failed`);
+            console.log(`[Cosmos][plugin:${plugin.name}] Export failed`);
             throw err;
         }
     }
@@ -56,25 +64,20 @@ async function copyStaticAssets(cosmosConfig) {
         return;
     }
     const { publicUrl } = cosmosConfig;
-    const exportStaticPath = path.resolve(exportPath, removeLeadingSlash(publicUrl));
+    const exportStaticPath = path.join(exportPath, publicUrl);
     fs.cp(staticPath, exportStaticPath, { recursive: true });
 }
-async function getExportPlugins(pluginConfigs, rootDir) {
-    return Promise.all(pluginConfigs
-        .filter(pluginConfig => pluginConfig.export)
-        .map(pluginConfig => requirePluginModule(rootDir, pluginConfig, 'export')));
-}
 async function exportPlaygroundFiles(cosmosConfig, pluginConfigs) {
     const { exportPath } = cosmosConfig;
     // Copy UI plugins to export path and embed them in the playground HTML
     // with updated paths
     const uiPlugins = pluginConfigs.filter(isUiPlugin);
     const copiedUiPlugins = await Promise.all(uiPlugins.map(p => exportUiPlugin(cosmosConfig, p)));
-    await fs.copyFile(resolve('react-cosmos-ui/dist/playground.bundle.js'), path.resolve(exportPath, 'playground.bundle.js'));
-    await fs.copyFile(resolve('react-cosmos-ui/dist/playground.bundle.js.map'), path.resolve(exportPath, 'playground.bundle.js.map'));
-    await fs.copyFile(getStaticPath('favicon.ico'), path.resolve(exportPath, '_cosmos.ico'));
+    await fs.copyFile(resolve('react-cosmos-ui/dist/playground.bundle.js'), path.join(exportPath, 'playground.bundle.js'));
+    await fs.copyFile(resolve('react-cosmos-ui/dist/playground.bundle.js.map'), path.join(exportPath, 'playground.bundle.js.map'));
+    await fs.copyFile(getStaticPath('favicon.ico'), path.join(exportPath, '_cosmos.ico'));
     const playgroundHtml = await getExportPlaygroundHtml(cosmosConfig, copiedUiPlugins);
-    await fs.writeFile(path.resolve(exportPath, 'index.html'), playgroundHtml);
+    await fs.writeFile(path.join(exportPath, 'index.html'), playgroundHtml);
 }
 async function exportUiPlugin(cosmosConfig, pluginConfig) {
     const { rootDir, exportPath } = cosmosConfig;

package/dist/{server/getFixtures → getFixtures}/getFixtures.d.ts

@@ -8,7 +8,11 @@ export type FixtureApi = {
     parents: string[];
     playgroundUrl: string;
     relativeFilePath: string;
-    rendererUrl: string;
+    rendererUrl: string | null;
     treePath: string[];
 };
-export declare function getFixtures(cosmosConfig: CosmosConfig): FixtureApi[];
+type Options = {
+    rendererUrl?: string;
+};
+export declare function getFixtures(cosmosConfig: CosmosConfig, options?: Options): FixtureApi[];
+export {};

package/dist/getFixtures/getFixtures.js

@@ -0,0 +1,53 @@
+import { mapValues } from 'lodash-es';
+import path from 'path';
+import { buildPlaygroundQueryString, createFixtureTree, createRendererUrl, flattenFixtureTree, getFixtureFromExport, getFixtureListFromExports, getSortedDecoratorsForFixturePath, } from 'react-cosmos-core';
+import { createFixtureNode, decorateFixture } from 'react-cosmos-renderer';
+import { getPlaygroundUrl } from '../shared/playgroundUrl.js';
+import { importUserModules } from './importUserModules.js';
+export function getFixtures(cosmosConfig, options = {}) {
+    const { fixtures, decorators } = importUserModules(cosmosConfig);
+    const fixtureExports = mapValues(fixtures, f => f.default);
+    const decoratorExports = mapValues(decorators, f => f.default);
+    const result = [];
+    getFlatFixtureTree(cosmosConfig, fixtureExports).forEach(({ fileName, fixtureId, name, parents }) => {
+        const fixtureExport = fixtures[fixtureId.path].default;
+        const fixture = getFixtureFromExport(fixtureExport, fixtureId.name);
+        if (!fixture) {
+            throw new Error(`Could not read fixture: ${JSON.stringify(fixtureId)}`);
+        }
+        const treePath = [...parents, fileName];
+        if (name)
+            treePath.push(name);
+        result.push({
+            absoluteFilePath: path.join(cosmosConfig.rootDir, fixtureId.path),
+            fileName,
+            getElement: createFixtureElementGetter(fixture, fixtureId.path, decoratorExports),
+            name,
+            parents,
+            playgroundUrl: getPlaygroundFixtureUrl(cosmosConfig, fixtureId),
+            relativeFilePath: fixtureId.path,
+            rendererUrl: options.rendererUrl
+                ? createRendererUrl(options.rendererUrl, fixtureId)
+                : null,
+            treePath,
+        });
+    });
+    return result;
+}
+function getFlatFixtureTree(cosmosConfig, fixtures) {
+    const { fixturesDir, fixtureFileSuffix } = cosmosConfig;
+    return flattenFixtureTree(createFixtureTree({
+        fixtures: getFixtureListFromExports(fixtures),
+        fixturesDir,
+        fixtureFileSuffix,
+    }));
+}
+function getPlaygroundFixtureUrl(cosmosConfig, fixtureId) {
+    const baseUrl = getPlaygroundUrl(cosmosConfig);
+    const query = buildPlaygroundQueryString({ fixtureId });
+    return `${baseUrl}/${query}`;
+}
+function createFixtureElementGetter(fixture, fixturePath, decoratorsByPath) {
+    const decorators = getSortedDecoratorsForFixturePath(fixturePath, decoratorsByPath);
+    return () => decorateFixture(createFixtureNode(fixture), decorators);
+}

package/dist/getFixtures/importUserModules.d.ts

@@ -0,0 +1,8 @@
+import { ByPath, ReactDecoratorModule, ReactFixtureModule } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+type UserModules = {
+    fixtures: ByPath<ReactFixtureModule>;
+    decorators: ByPath<ReactDecoratorModule>;
+};
+export declare function importUserModules({ rootDir, fixturesDir, fixtureFileSuffix, ignore, }: CosmosConfig): UserModules;
+export {};

package/dist/getFixtures/importUserModules.js

@@ -0,0 +1,28 @@
+import path from 'path';
+import { findUserModulePaths } from '../userModules/findUserModulePaths.js';
+import { slash } from '../utils/slash.js';
+export function importUserModules({ rootDir, fixturesDir, fixtureFileSuffix, ignore, }) {
+    const { fixturePaths, decoratorPaths } = findUserModulePaths({
+        rootDir,
+        fixturesDir,
+        fixtureFileSuffix,
+        ignore,
+    });
+    return {
+        fixtures: importModules(fixturePaths, rootDir),
+        decorators: importModules(decoratorPaths, rootDir),
+    };
+}
+function importModules(paths, rootDir) {
+    const modules = paths.map(p => {
+        // Converting to forward slashes on Windows is important because the
+        // slashes are used for generating a sorted list of fixtures and
+        // decorators.
+        const relPath = slash(path.relative(rootDir, p));
+        return { relPath, module: require(p) };
+    });
+    return modules.reduce((acc, { relPath, module }) => ({
+        ...acc,
+        [relPath]: module,
+    }), {});
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from './cosmosConfig/createCosmosConfig.js';
+export * from './cosmosConfig/detectCosmosConfig.js';
+export * from './cosmosConfig/getCosmosConfigAtPath.js';
+export * from './cosmosConfig/types.js';
+export * from './cosmosPlugin/findCosmosPluginConfigs.js';
+export * from './cosmosPlugin/pluginConfigs.js';
+export * from './cosmosPlugin/types.js';
+export * from './getFixtures/getFixtures.js';
+export * from './shared/findNextAvailablePort.js';
+export * from './shared/playgroundUrl.js';
+export * from './shared/staticServer.js';
+export * from './testHelpers/cwd.js';
+export * from './userModules/fixtureWatcher.js';
+export * from './userModules/generateUserImports.js';
+export * from './utils/cli.js';
+export * from './utils/fs.js';
+export * from './utils/requireSilent.js';
+export * from './utils/resolve.js';
+export * from './utils/resolveLoose.js';
+export * from './utils/resolveSilent.js';

package/dist/index.js

@@ -1 +1,20 @@
-"use strict";
+export * from './cosmosConfig/createCosmosConfig.js';
+export * from './cosmosConfig/detectCosmosConfig.js';
+export * from './cosmosConfig/getCosmosConfigAtPath.js';
+export * from './cosmosConfig/types.js';
+export * from './cosmosPlugin/findCosmosPluginConfigs.js';
+export * from './cosmosPlugin/pluginConfigs.js';
+export * from './cosmosPlugin/types.js';
+export * from './getFixtures/getFixtures.js';
+export * from './shared/findNextAvailablePort.js';
+export * from './shared/playgroundUrl.js';
+export * from './shared/staticServer.js';
+export * from './testHelpers/cwd.js';
+export * from './userModules/fixtureWatcher.js';
+export * from './userModules/generateUserImports.js';
+export * from './utils/cli.js';
+export * from './utils/fs.js';
+export * from './utils/requireSilent.js';
+export * from './utils/resolve.js';
+export * from './utils/resolveLoose.js';
+export * from './utils/resolveSilent.js';

package/dist/jest.d.ts

@@ -1,7 +1,4 @@
-export * from './server/testHelpers/mockConsole.js';
-export * from './server/testHelpers/mockEsmRequire.js';
-export * from './server/testHelpers/mockEsmResolve.js';
-export * from './server/testHelpers/mockEsmStaticPath.js';
-export * from './server/testHelpers/mockFetch.js';
-export * from './server/testHelpers/mockFs.js';
-export * from './server/testHelpers/mockYargs.js';
+export * from './testHelpers/mockConsole.js';
+export * from './testHelpers/mockFetch.js';
+export * from './testHelpers/mockFs.js';
+export * from './testHelpers/mockYargs.js';

package/dist/jest.js

@@ -1,7 +1,4 @@
-export * from './server/testHelpers/mockConsole.js';
-export * from './server/testHelpers/mockEsmRequire.js';
-export * from './server/testHelpers/mockEsmResolve.js';
-export * from './server/testHelpers/mockEsmStaticPath.js';
-export * from './server/testHelpers/mockFetch.js';
-export * from './server/testHelpers/mockFs.js';
-export * from './server/testHelpers/mockYargs.js';
+export * from './testHelpers/mockConsole.js';
+export * from './testHelpers/mockFetch.js';
+export * from './testHelpers/mockFs.js';
+export * from './testHelpers/mockYargs.js';

package/dist/shared/applyServerConfigPlugins.d.ts

@@ -0,0 +1,11 @@
+import { CosmosCommand } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+import { CosmosPlatform, CosmosServerPlugin } from '../cosmosPlugin/types.js';
+type Args = {
+    cosmosConfig: CosmosConfig;
+    serverPlugins: CosmosServerPlugin[];
+    command: CosmosCommand;
+    platform: CosmosPlatform;
+};
+export declare function applyServerConfigPlugins({ cosmosConfig, serverPlugins, command, platform, }: Args): Promise<CosmosConfig>;
+export {};

package/dist/shared/applyServerConfigPlugins.js

@@ -0,0 +1,14 @@
+export async function applyServerConfigPlugins({ cosmosConfig, serverPlugins, command, platform, }) {
+    for (const plugin of serverPlugins) {
+        if (plugin.config) {
+            try {
+                cosmosConfig = await plugin.config({ cosmosConfig, command, platform });
+            }
+            catch (err) {
+                console.log(`[Cosmos][plugin:${plugin.name}] Config hook failed`);
+                throw err;
+            }
+        }
+    }
+    return cosmosConfig;
+}

package/dist/shared/findNextAvailablePort.d.ts

@@ -0,0 +1 @@
+export declare function findNextAvailablePort(port: number, retries: number, retriesLeft?: number): Promise<number>;

package/dist/shared/findNextAvailablePort.js

@@ -0,0 +1,29 @@
+import net from 'net';
+// Inspired by https://stackoverflow.com/q/19129570
+export async function findNextAvailablePort(port, retries, retriesLeft = retries) {
+    return new Promise((resolve, reject) => {
+        const socket = new net.Socket();
+        socket.on('connect', () => {
+            console.log(`[Cosmos] Port ${port} already in use, trying next...`);
+            if (retriesLeft > 0) {
+                socket.destroy();
+                resolve(findNextAvailablePort(port + 1, retries, retriesLeft - 1));
+            }
+            else {
+                reject(`No available port found after ${retries} retries.`);
+            }
+        });
+        socket.on('error', (error) => {
+            if (error.code === 'ECONNREFUSED')
+                resolve(port);
+            else
+                reject(error);
+        });
+        socket.setTimeout(400);
+        socket.on('timeout', () => {
+            socket.destroy();
+            resolve(port);
+        });
+        socket.connect(port, '0.0.0.0');
+    });
+}

package/dist/shared/getServerPlugins.d.ts

@@ -0,0 +1,2 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+export declare function getServerPlugins(pluginConfigs: CosmosPluginConfig[], rootDir: string): Promise<import("../index.js").CosmosServerPlugin[]>;

package/dist/shared/getServerPlugins.js

@@ -0,0 +1,6 @@
+import { coreServerPlugins } from '../corePlugins/index.js';
+import { importServerPlugins } from './importServerPlugins.js';
+export async function getServerPlugins(pluginConfigs, rootDir) {
+    const userPlugins = await importServerPlugins(pluginConfigs, rootDir);
+    return [...coreServerPlugins, ...userPlugins];
+}

package/dist/shared/importServerPlugins.d.ts

@@ -0,0 +1,3 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+import { CosmosServerPlugin } from '../cosmosPlugin/types.js';
+export declare function importServerPlugins(pluginConfigs: CosmosPluginConfig[], rootDir: string): Promise<CosmosServerPlugin[]>;

package/dist/shared/importServerPlugins.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { importModule } from '../utils/fs.js';
+export async function importServerPlugins(pluginConfigs, rootDir) {
+    return Promise.all(pluginConfigs
+        .filter(pluginConfig => pluginConfig.server)
+        .map(pluginConfig => importServerModule(pluginConfig, rootDir)));
+}
+async function importServerModule(pluginConfig, rootDir) {
+    const modulePath = pluginConfig.server;
+    if (!modulePath) {
+        throw new Error(`Server module missing in plugin "${pluginConfig.name}"`);
+    }
+    const absPath = path.resolve(rootDir, modulePath);
+    const module = await importModule(absPath);
+    return module.default;
+}

package/dist/shared/playgroundHtml.d.ts

@@ -0,0 +1,5 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+import { CosmosPlatform } from '../cosmosPlugin/types.js';
+export declare function getDevPlaygroundHtml(platform: CosmosPlatform, cosmosConfig: CosmosConfig, pluginConfigs: CosmosPluginConfig[]): Promise<string>;
+export declare function getExportPlaygroundHtml(cosmosConfig: CosmosConfig, pluginConfigs: CosmosPluginConfig[]): Promise<string>;

package/dist/{server/shared → shared}/playgroundHtml.js

@@ -2,16 +2,22 @@ import fs from 'fs';
 import { readFile } from 'fs/promises';
 import path from 'path';
 import { pkgUpSync } from 'pkg-up';
-import { replaceKeys } from 'react-cosmos-core';
-import { resolveRendererUrl } from './resolveRendererUrl.js';
+import { pickRendererUrl, replaceKeys, } from 'react-cosmos-core';
+import { findUserModulePaths } from '../userModules/findUserModulePaths.js';
+import { importKeyPath } from '../userModules/shared.js';
 import { getStaticPath } from './staticPath.js';
-export const RENDERER_FILENAME = '_renderer.html';
-export async function getDevPlaygroundHtml(platformType, cosmosConfig, pluginConfigs) {
+export async function getDevPlaygroundHtml(platform, cosmosConfig, pluginConfigs) {
     const { ui } = cosmosConfig;
     return getPlaygroundHtml({
         playgroundConfig: {
             ...ui,
-            core: await getDevCoreConfig(platformType, cosmosConfig),
+            core: await getCoreConfig(cosmosConfig, true),
+            rendererCore: {
+                fixtures: getFixtureList(cosmosConfig),
+                rendererUrl: platform === 'web'
+                    ? pickRendererUrl(cosmosConfig.rendererUrl, 'dev')
+                    : null,
+            },
         },
         pluginConfigs,
     });
@@ -21,43 +27,22 @@ export async function getExportPlaygroundHtml(cosmosConfig, pluginConfigs) {
     return getPlaygroundHtml({
         playgroundConfig: {
             ...ui,
-            core: await getExportCoreConfig(cosmosConfig),
+            core: await getCoreConfig(cosmosConfig, false),
+            rendererCore: {
+                fixtures: getFixtureList(cosmosConfig),
+                rendererUrl: pickRendererUrl(cosmosConfig.rendererUrl, 'export'),
+            },
         },
         pluginConfigs,
     });
 }
-async function getDevCoreConfig(platformType, cosmosConfig) {
-    switch (platformType) {
-        case 'native':
-            return {
-                ...(await getSharedCoreConfig(cosmosConfig)),
-                devServerOn: true,
-                webRendererUrl: null,
-            };
-        case 'web':
-            return {
-                ...(await getSharedCoreConfig(cosmosConfig)),
-                devServerOn: true,
-                webRendererUrl: cosmosConfig.rendererUrl ||
-                    resolveRendererUrl(cosmosConfig.publicUrl, RENDERER_FILENAME),
-            };
-        default:
-            throw new Error(`Invalid platform type: ${platformType}`);
-    }
-}
-async function getExportCoreConfig(cosmosConfig) {
-    return {
-        ...(await getSharedCoreConfig(cosmosConfig)),
-        devServerOn: false,
-        webRendererUrl: resolveRendererUrl(cosmosConfig.publicUrl, RENDERER_FILENAME),
-    };
-}
-async function getSharedCoreConfig(cosmosConfig) {
+async function getCoreConfig(cosmosConfig, devServerOn) {
     const { rootDir, fixturesDir, fixtureFileSuffix } = cosmosConfig;
     return {
         projectId: await getProjectId(rootDir),
         fixturesDir,
         fixtureFileSuffix,
+        devServerOn,
     };
 }
 async function getProjectId(rootDir) {
@@ -83,3 +68,10 @@ function getPlaygroundHtml(playgroundArgs) {
 function getPlaygroundHtmlTemplate() {
     return fs.readFileSync(getStaticPath('index.html'), 'utf8');
 }
+function getFixtureList(cosmosConfig) {
+    const { fixturePaths } = findUserModulePaths(cosmosConfig);
+    return fixturePaths.reduce((acc, fixturePath) => ({
+        ...acc,
+        [importKeyPath(fixturePath, cosmosConfig.rootDir)]: { type: 'single' },
+    }), {});
+}

package/dist/shared/staticPath.d.ts

@@ -0,0 +1 @@
+export declare function getStaticPath(relPath: string): string;

package/dist/{server/shared → shared}/staticServer.js

@@ -1,6 +1,5 @@
 import express from 'express';
 import path from 'path';
-import { removeLeadingDot } from 'react-cosmos-core';
 export function serveStaticDir(app, staticPath, publicUrl) {
     const relStaticPath = path.relative(process.cwd(), staticPath);
     console.log(`[Cosmos] Serving static files from ${relStaticPath}`);
@@ -10,3 +9,6 @@ export function serveStaticDir(app, staticPath, publicUrl) {
         index: false,
     }));
 }
+function removeLeadingDot(fromPath) {
+    return fromPath.indexOf('.') === 0 ? fromPath.slice(1) : fromPath;
+}

package/dist/{server/testHelpers → testHelpers}/mockConsole.js

@@ -1,11 +1,15 @@
 export async function mockConsole(cb) {
-    const origConsoleLog = console.log;
-    console.log = jest.fn();
     const expectedLogs = [];
-    const ret = await cb({
+    const origConsoleLog = console.log;
+    console.log = jest.fn((...args) => {
+        if (typeof args[0] !== 'string' || !expectedLogs.includes(args[0])) {
+            origConsoleLog(...args);
+        }
+    });
+    const cbReturn = await cb({
         expectLog: (msg) => expectedLogs.push(msg),
     });
     expectedLogs.forEach(msg => expect(console.log).toBeCalledWith(msg));
     console.log = origConsoleLog;
-    return ret;
+    return cbReturn;
 }

package/dist/{server/testHelpers → testHelpers}/mockFs.d.ts

@@ -1,5 +1,5 @@
 import { CosmosConfig } from '../cosmosConfig/types.js';
+export declare function mockFile(filePath: string, fileMock: {}): void;
 export declare function mockCosmosConfig(cosmosConfigPath: string, cosmosConfig: Partial<CosmosConfig>): void;
-export declare function mockFile(filePath: string, fileContent: {}): void;
-export declare function mockDir(dirPath: string): void;
+export declare function mockCwdModuleDefault(filePath: string, fileMock: {}): void;
 export declare function resetFsMock(): void;