react-cosmos 5.7.2 → 6.0.0-alpha.5

package/bin/cosmos-export.js

@@ -3,10 +3,11 @@
 // Set the env before any code reads it
 process.env.NODE_ENV = process.env.NODE_ENV || 'production';
 
-require('regenerator-runtime/runtime');
-const { generateWebExport } = require('../dist/generateWebExport');
+const { generateExport } = await import(
+  '../dist/server/export/generateExport.js'
+);
 
-generateWebExport().catch(err => {
+generateExport().catch(err => {
   console.log('[Cosmos] Export failed...');
   console.log(`\n  (╯°□°)╯︵ ┻━┻\n`);
   console.log(err);

package/bin/cosmos-native.js

@@ -3,10 +3,11 @@
 // Set the env before any code reads it
 process.env.NODE_ENV = process.env.NODE_ENV || 'development';
 
-require('regenerator-runtime/runtime');
-const { startNativeServer } = require('../dist/startNativeServer');
+const { startDevServer } = await import(
+  '../dist/server/devServer/startDevServer.js'
+);
 
-startNativeServer().catch(err => {
+startDevServer('native').catch(err => {
   console.log('[Cosmos] Server crashed...');
   console.log(`\n  (╯°□°)╯︵ ┻━┻\n`);
   console.log(err);

package/bin/cosmos.js

@@ -3,14 +3,15 @@
 // Set the env before any code reads it
 process.env.NODE_ENV = process.env.NODE_ENV || 'development';
 
+const { startDevServer } = await import(
+  '../dist/server/devServer/startDevServer.js'
+);
+
 // Auto disable Fast Refresh in CRA 4 until integration is implemented
 // https://github.com/react-cosmos/react-cosmos/issues/1272
 process.env.FAST_REFRESH = process.env.FAST_REFRESH || false;
 
-require('regenerator-runtime/runtime');
-const { startWebServer } = require('../dist/startWebServer');
-
-startWebServer().catch(err => {
+startDevServer('web').catch(err => {
   console.log('[Cosmos] Server crashed...');
   console.log(`\n  (╯°□°)╯︵ ┻━┻\n`);
   console.log(err);

package/config.schema.json

@@ -17,8 +17,12 @@
       "type": "string",
       "minLength": 1
     },
+    "detectLocalPlugins": {
+      "description": "Automatically detect and load local plugins",
+      "type": "boolean"
+    },
     "disablePlugins": {
-      "description": "Disable plugins",
+      "description": "Disable all plugins 3rd party plugins",
       "type": "boolean"
     },
     "staticPath": {
@@ -26,6 +30,12 @@
       "type": "string",
       "minLength": 1
     },
+    "plugins": {
+      "description": "Module IDs of Cosmos plugins (eg. \"react-cosmos-plugin-open-fixture\" or \"../path/to/my-plugin\").",
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 },
+      "uniqueItems": true
+    },
     "publicUrl": {
       "description": "Base URL for static assets. [default: \"/\"]",
       "type": "string"
@@ -117,8 +127,8 @@
       "items": { "type": "string", "minLength": 1 },
       "uniqueItems": true
     },
-    "experimentalRendererUrl": {
-      "description": "Custom renderer URL. This setting disables webpack bundling and allows integration with other build tools like Snowpack. [default: null]",
+    "rendererUrl": {
+      "description": "Required when renderer doesn't run on the same port (or host) as the Playground. Useful for integrations with build tools. [default: null]",
       "anyOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }]
     },
     "dom": {
@@ -154,7 +164,7 @@
           "type": "boolean"
         },
         "reloadOnFail": {
-          "description": "When using webpack's Hot Module Replacement, enable automatic location reload after webpack fails to update modules. [default: true]",
+          "description": "When using webpack's Hot Module Replacement, enable automatic location reload after webpack fails to update modules. [default: false]",
           "type": "boolean"
         }
       }

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export { createCosmosConfig } from './config/createCosmosConfig';
-export { detectCosmosConfig } from './config/detectCosmosConfig';
-export { getCosmosConfigAtPath } from './config/getCosmosConfigAtPath';
-export { getFixtures, getFixturesSync } from './getFixtures';
-export { FixtureApi, getFixtures2 } from './getFixtures2';
-export { getFixtureUrls, getFixtureUrlsSync } from './getFixtureUrls';

package/dist/index.js

@@ -1,71 +1 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "FixtureApi", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtures2.FixtureApi;
-  }
-});
-Object.defineProperty(exports, "createCosmosConfig", {
-  enumerable: true,
-  get: function get() {
-    return _createCosmosConfig.createCosmosConfig;
-  }
-});
-Object.defineProperty(exports, "detectCosmosConfig", {
-  enumerable: true,
-  get: function get() {
-    return _detectCosmosConfig.detectCosmosConfig;
-  }
-});
-Object.defineProperty(exports, "getCosmosConfigAtPath", {
-  enumerable: true,
-  get: function get() {
-    return _getCosmosConfigAtPath.getCosmosConfigAtPath;
-  }
-});
-Object.defineProperty(exports, "getFixtureUrls", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtureUrls.getFixtureUrls;
-  }
-});
-Object.defineProperty(exports, "getFixtureUrlsSync", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtureUrls.getFixtureUrlsSync;
-  }
-});
-Object.defineProperty(exports, "getFixtures", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtures.getFixtures;
-  }
-});
-Object.defineProperty(exports, "getFixtures2", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtures2.getFixtures2;
-  }
-});
-Object.defineProperty(exports, "getFixturesSync", {
-  enumerable: true,
-  get: function get() {
-    return _getFixtures.getFixturesSync;
-  }
-});
-
-var _createCosmosConfig = require("./config/createCosmosConfig");
-
-var _detectCosmosConfig = require("./config/detectCosmosConfig");
-
-var _getCosmosConfigAtPath = require("./config/getCosmosConfigAtPath");
-
-var _getFixtures = require("./getFixtures");
-
-var _getFixtures2 = require("./getFixtures2");
-
-var _getFixtureUrls = require("./getFixtureUrls");

package/dist/jest.d.ts

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

package/dist/jest.js

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

package/dist/{config → server/cosmosConfig}/createCosmosConfig.d.ts

@@ -1,2 +1,2 @@
-import { CosmosConfig, CosmosConfigInput } from './shared';
+import { CosmosConfig, CosmosConfigInput } from './types.js';
 export declare function createCosmosConfig(rootDir: string, cosmosConfigInput?: CosmosConfigInput): CosmosConfig;

package/dist/server/cosmosConfig/createCosmosConfig.js

@@ -0,0 +1,84 @@
+import path from 'path';
+import { getCliArgs } from '../utils/cli.js';
+import { resolveLoose } from '../utils/resolveLoose.js';
+export function createCosmosConfig(rootDir, cosmosConfigInput = {}) {
+    return {
+        ...cosmosConfigInput,
+        rootDir,
+        exportPath: getExportPath(cosmosConfigInput, rootDir),
+        detectLocalPlugins: cosmosConfigInput.detectLocalPlugins ?? true,
+        disablePlugins: cosmosConfigInput.disablePlugins ?? false,
+        fixtureFileSuffix: getFixtureFileSuffix(cosmosConfigInput),
+        fixturesDir: getFixturesDir(cosmosConfigInput),
+        globalImports: getGlobalImports(cosmosConfigInput, rootDir),
+        hostname: getHostname(cosmosConfigInput),
+        https: getHttps(cosmosConfigInput),
+        httpsOptions: getHttpsOptions(cosmosConfigInput, rootDir),
+        port: getPort(cosmosConfigInput),
+        plugins: getPlugins(cosmosConfigInput, rootDir),
+        publicUrl: getPublicUrl(cosmosConfigInput),
+        staticPath: getStaticPath(cosmosConfigInput, rootDir),
+        userDepsFilePath: getUserDepsFilePath(cosmosConfigInput, rootDir),
+        watchDirs: getWatchDirs(cosmosConfigInput, rootDir),
+        rendererUrl: cosmosConfigInput.rendererUrl ?? null,
+        ui: cosmosConfigInput.ui || {},
+    };
+}
+function getExportPath(cosmosConfigInput, rootDir) {
+    const { exportPath = 'cosmos-export' } = cosmosConfigInput;
+    return path.resolve(rootDir, exportPath);
+}
+function getStaticPath(cosmosConfigInput, rootDir) {
+    const { staticPath = null } = cosmosConfigInput;
+    return staticPath && path.resolve(rootDir, staticPath);
+}
+function getHttps(cosmosConfigInput) {
+    const { https = false } = cosmosConfigInput;
+    return https;
+}
+function getHttpsOptions(cosmosConfigInput, rootDir) {
+    if (cosmosConfigInput.httpsOptions?.keyPath &&
+        cosmosConfigInput.httpsOptions?.certPath) {
+        return {
+            keyPath: path.resolve(rootDir, cosmosConfigInput.httpsOptions.keyPath),
+            certPath: path.resolve(rootDir, cosmosConfigInput.httpsOptions.certPath),
+        };
+    }
+    return null;
+}
+function getPublicUrl({ publicUrl = '/' }) {
+    return publicUrl;
+}
+function getFixturesDir({ fixturesDir = '__fixtures__' }) {
+    return fixturesDir;
+}
+function getFixtureFileSuffix({ fixtureFileSuffix = 'fixture', }) {
+    return fixtureFileSuffix;
+}
+function getWatchDirs(cosmosConfigInput, rootDir) {
+    const { watchDirs = ['.'] } = cosmosConfigInput;
+    return watchDirs.map(watchDir => path.resolve(rootDir, watchDir));
+}
+function getUserDepsFilePath(cosmosConfigInput, rootDir) {
+    const { userDepsFilePath = 'cosmos.userdeps.js' } = cosmosConfigInput;
+    return path.resolve(rootDir, userDepsFilePath);
+}
+function getHostname({ hostname = null }) {
+    return hostname;
+}
+function getPort(cosmosConfigInput) {
+    const cliArgs = getCliArgs();
+    if (typeof cliArgs.port === 'number') {
+        return cliArgs.port;
+    }
+    const { port = 5000 } = cosmosConfigInput;
+    return port;
+}
+function getGlobalImports(cosmosConfigInput, rootDir) {
+    const { globalImports = [] } = cosmosConfigInput;
+    return globalImports.map(globalImport => resolveLoose(rootDir, globalImport));
+}
+function getPlugins(cosmosConfigInput, rootDir) {
+    const { plugins = [] } = cosmosConfigInput;
+    return plugins.map(plugin => resolveLoose(rootDir, plugin));
+}

package/dist/server/cosmosConfig/detectCosmosConfig.d.ts

@@ -0,0 +1,2 @@
+export declare function detectCosmosConfig(): Promise<import("./types.js").CosmosConfig>;
+export declare function detectCosmosConfigPath(): string | null;

package/dist/server/cosmosConfig/detectCosmosConfig.js

@@ -0,0 +1,38 @@
+import path from 'path';
+import { getCliArgs } from '../utils/cli.js';
+import { dirExists, fileExists, moduleExists } from '../utils/fs.js';
+import { createCosmosConfig } from './createCosmosConfig.js';
+import { getCosmosConfigAtPath } from './getCosmosConfigAtPath.js';
+import { getCurrentDir } from './shared.js';
+export async function detectCosmosConfig() {
+    const cosmosConfigPath = detectCosmosConfigPath();
+    return cosmosConfigPath
+        ? getCosmosConfigAtPath(cosmosConfigPath)
+        : createCosmosConfig(detectRootDir());
+}
+export function detectCosmosConfigPath() {
+    const rootDir = detectRootDir();
+    const cliArgs = getCliArgs();
+    // CLI support for --config path/to/cosmos.config.json
+    if (typeof cliArgs.config === 'string') {
+        if (path.extname(cliArgs.config) !== '.json')
+            throw new Error(`[Cosmos] Invalid config file type: ${cliArgs.config} (must be .json)`);
+        const absPath = path.resolve(rootDir, cliArgs.config);
+        if (!fileExists(absPath))
+            throw new Error(`[Cosmos] Config not found at path: ${cliArgs.config}`);
+        return absPath;
+    }
+    const defaultConfigPath = path.join(rootDir, 'cosmos.config.json');
+    return moduleExists(defaultConfigPath) ? defaultConfigPath : null;
+}
+function detectRootDir() {
+    const cliArgs = getCliArgs();
+    // CLI support for --root-dir path/to/project
+    if (typeof cliArgs.rootDir === 'string') {
+        const absPath = path.resolve(getCurrentDir(), cliArgs.rootDir);
+        if (!dirExists(absPath))
+            throw new Error(`[Cosmos] Dir not found at path: ${cliArgs.rootDir}`);
+        return absPath;
+    }
+    return getCurrentDir();
+}

package/dist/{config → server/cosmosConfig}/getCosmosConfigAtPath.d.ts

@@ -1 +1 @@
-export declare function getCosmosConfigAtPath(cosmosConfigPath: string): import("./shared").CosmosConfig;
+export declare function getCosmosConfigAtPath(cosmosConfigPath: string): Promise<import("./types.js").CosmosConfig>;

package/dist/server/cosmosConfig/getCosmosConfigAtPath.js

@@ -0,0 +1,12 @@
+import path from 'path';
+import { createCosmosConfig } from './createCosmosConfig.js';
+import { importConfigFile } from './shared.js';
+export async function getCosmosConfigAtPath(cosmosConfigPath) {
+    const cosmosConfigInput = await importConfigFile(cosmosConfigPath);
+    const rootDir = deriveRootDir(cosmosConfigPath, cosmosConfigInput);
+    return createCosmosConfig(rootDir, cosmosConfigInput);
+}
+function deriveRootDir(cosmosConfigPath, { rootDir }) {
+    const configDir = path.dirname(cosmosConfigPath);
+    return rootDir ? path.resolve(configDir, rootDir) : configDir;
+}

package/dist/server/cosmosConfig/shared.d.ts

@@ -0,0 +1,2 @@
+export declare function getCurrentDir(): string;
+export declare function importConfigFile(cosmosConfigPath: string): Promise<Partial<import("./types.js").CosmosConfig>>;

package/dist/server/cosmosConfig/shared.js

@@ -0,0 +1,7 @@
+import { importModule } from '../utils/fs.js';
+export function getCurrentDir() {
+    return process.cwd();
+}
+export async function importConfigFile(cosmosConfigPath) {
+    return importModule(cosmosConfigPath);
+}

package/dist/{config/shared.d.ts → server/cosmosConfig/types.d.ts}

@@ -2,8 +2,9 @@ interface HttpsOptions {
     keyPath: string;
     certPath: string;
 }
-export declare type CosmosConfig = {
+export type CosmosConfig = {
     exportPath: string;
+    detectLocalPlugins: boolean;
     disablePlugins: boolean;
     fixtureFileSuffix: string;
     fixturesDir: string;
@@ -12,18 +13,17 @@ export declare type CosmosConfig = {
     https: boolean;
     httpsOptions: null | HttpsOptions;
     port: number;
+    plugins: string[];
     publicUrl: string;
+    rendererUrl: string | null;
     rootDir: string;
     staticPath: null | string;
     userDepsFilePath: string;
     watchDirs: string[];
-    experimentalRendererUrl: string | null;
     [option: string]: unknown;
     ui: {
         [pluginName: string]: {};
     };
 };
-export declare type CosmosConfigInput = Partial<CosmosConfig>;
-export declare function getCurrentDir(): string;
-export declare function requireConfigFile(cosmosConfigPath: string): CosmosConfigInput;
+export type CosmosConfigInput = Partial<CosmosConfig>;
 export {};

package/dist/server/cosmosPlugin/findCosmosPluginConfigs.d.ts

@@ -0,0 +1,8 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+type Args = {
+    rootDir: string;
+    relativePaths: boolean;
+    ignore?: string[];
+};
+export declare function findCosmosPluginConfigs({ rootDir, relativePaths, ignore, }: Args): Promise<CosmosPluginConfig[]>;
+export {};

package/dist/server/cosmosPlugin/findCosmosPluginConfigs.js

@@ -0,0 +1,14 @@
+import glob from 'glob';
+import { readCosmosPluginConfig } from './readCosmosPluginConfig.js';
+export async function findCosmosPluginConfigs({ rootDir, relativePaths, ignore, }) {
+    const configPaths = findCosmosPluginConfigPaths(rootDir, ignore);
+    return Promise.all(configPaths.map(configPath => readCosmosPluginConfig({ rootDir, configPath, relativePaths })));
+}
+const defaultIgnore = ['**/node_modules/**'];
+function findCosmosPluginConfigPaths(rootDir, ignore = defaultIgnore) {
+    return glob.sync('**/cosmos.plugin.json', {
+        cwd: rootDir,
+        absolute: true,
+        ignore,
+    });
+}

package/dist/server/cosmosPlugin/pluginConfigs.d.ts

@@ -0,0 +1,8 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+type GetPluginConfigArgs = {
+    cosmosConfig: CosmosConfig;
+    relativePaths: boolean;
+};
+export declare function getPluginConfigs({ cosmosConfig, relativePaths, }: GetPluginConfigArgs): Promise<CosmosPluginConfig[]>;
+export {};

package/dist/server/cosmosPlugin/pluginConfigs.js

@@ -0,0 +1,16 @@
+import { findCosmosPluginConfigs } from './findCosmosPluginConfigs.js';
+import { readCosmosPluginConfig } from './readCosmosPluginConfig.js';
+export async function getPluginConfigs({ cosmosConfig, relativePaths, }) {
+    const { rootDir, detectLocalPlugins, disablePlugins, plugins, exportPath } = cosmosConfig;
+    if (disablePlugins)
+        return [];
+    const moduleConfigs = await Promise.all(plugins.map(configPath => readCosmosPluginConfig({ rootDir, configPath, relativePaths })));
+    if (!detectLocalPlugins)
+        return moduleConfigs;
+    const localConfigs = await findCosmosPluginConfigs({
+        rootDir,
+        ignore: [`${exportPath}/**`],
+        relativePaths,
+    });
+    return [...moduleConfigs, ...localConfigs];
+}

package/dist/server/cosmosPlugin/readCosmosPluginConfig.d.ts

@@ -0,0 +1,8 @@
+import { CosmosPluginConfig } from 'react-cosmos-core';
+type ReadCosmosPluginConfigArgs = {
+    rootDir: string;
+    configPath: string;
+    relativePaths: boolean;
+};
+export declare function readCosmosPluginConfig({ rootDir, configPath, relativePaths, }: ReadCosmosPluginConfigArgs): Promise<CosmosPluginConfig>;
+export {};

package/dist/server/cosmosPlugin/readCosmosPluginConfig.js

@@ -0,0 +1,31 @@
+import path from 'path';
+import { importModule } from '../utils/fs.js';
+import { resolveSilent } from '../utils/resolveSilent.js';
+export async function readCosmosPluginConfig({ rootDir, configPath, relativePaths, }) {
+    const rawConfig = await importModule(configPath);
+    const pluginRootDir = path.dirname(configPath);
+    const config = {
+        name: rawConfig.name,
+        rootDir: relativePaths
+            ? path.relative(rootDir, pluginRootDir)
+            : pluginRootDir,
+    };
+    if (rawConfig.ui) {
+        config.ui = resolvePluginPath(config.name, rootDir, pluginRootDir, rawConfig.ui, relativePaths);
+    }
+    if (rawConfig.devServer) {
+        config.devServer = resolvePluginPath(config.name, rootDir, pluginRootDir, rawConfig.devServer, relativePaths);
+    }
+    if (rawConfig.export) {
+        config.export = resolvePluginPath(config.name, rootDir, pluginRootDir, rawConfig.export, relativePaths);
+    }
+    return config;
+}
+function resolvePluginPath(pluginName, rootDir, pluginRootDir, filePath, relativePath) {
+    const absolutePath = path.join(pluginRootDir, filePath);
+    const resolvedPath = resolveSilent(absolutePath);
+    if (!resolvedPath) {
+        throw new Error(`Invalid path in plugin "${pluginName}": ${filePath}`);
+    }
+    return relativePath ? path.relative(rootDir, resolvedPath) : resolvedPath;
+}

package/dist/server/cosmosPlugin/types.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import express from 'express';
+import http from 'http';
+import { MessageType } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+export type PlatformType = 'web' | 'native';
+export type DevServerPluginArgs = {
+    cosmosConfig: CosmosConfig;
+    platformType: PlatformType;
+    httpServer: http.Server;
+    expressApp: express.Express;
+    sendMessage(msg: MessageType): unknown;
+};
+export type DevServerPluginCleanupCallback = () => unknown;
+export type DevServerPluginReturnValue = void | null | DevServerPluginCleanupCallback;
+export type DevServerPluginReturn = DevServerPluginReturnValue | Promise<DevServerPluginReturnValue>;
+export type DevServerPlugin = (args: DevServerPluginArgs) => DevServerPluginReturn;
+export type ExportPluginArgs = {
+    cosmosConfig: CosmosConfig;
+};
+export type ExportPlugin = (args: ExportPluginArgs) => unknown;

package/dist/server/devServer/corePlugins/httpProxy.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../../cosmosPlugin/types.js';
+export declare function httpProxyDevServerPlugin({ platformType, cosmosConfig, expressApp, }: DevServerPluginArgs): void;

package/dist/server/devServer/corePlugins/httpProxy.js

@@ -0,0 +1,18 @@
+import { createProxyMiddleware } from 'http-proxy-middleware';
+export function httpProxyDevServerPlugin({ platformType, cosmosConfig, expressApp, }) {
+    if (platformType !== 'web')
+        return;
+    const httpProxyConfig = getHttpProxyCosmosConfig(cosmosConfig);
+    Object.keys(httpProxyConfig).forEach(context => {
+        const config = httpProxyConfig[context];
+        if (typeof config === 'string') {
+            expressApp.use(context, createProxyMiddleware(context, { target: config }));
+        }
+        else if (typeof config === 'object') {
+            expressApp.use(context, createProxyMiddleware(context, config));
+        }
+    });
+}
+function getHttpProxyCosmosConfig(cosmosConfig) {
+    return (cosmosConfig.httpProxy || {});
+}

package/dist/server/devServer/corePlugins/openFile.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../../cosmosPlugin/types.js';
+export default function openFileDevServerPlugin({ cosmosConfig, expressApp, }: DevServerPluginArgs): void;

package/dist/server/devServer/corePlugins/openFile.js

@@ -0,0 +1,53 @@
+import launchEditor from '@skidding/launch-editor';
+import fs from 'fs';
+import open from 'open';
+import path from 'path';
+export default function openFileDevServerPlugin({ cosmosConfig, expressApp, }) {
+    expressApp.get('/_open', (req, res) => {
+        const { filePath, line, column } = getReqQuery(req);
+        if (!filePath) {
+            res.status(400).send(`File path missing`);
+            return;
+        }
+        const absFilePath = resolveFilePath(cosmosConfig.rootDir, filePath);
+        if (!fs.existsSync(absFilePath)) {
+            res.status(404).send(`File not found at path: ${absFilePath}`);
+            return;
+        }
+        new Promise((resolve, reject) => {
+            const file = `${absFilePath}:${line}:${column}`;
+            launchEditor(file, (fileName, errorMsg) => reject(errorMsg));
+            // If launchEditor doesn't report error within 500ms we assume it worked
+            setTimeout(resolve, 500);
+        })
+            // Fall back to open in case launchEditor fails. launchEditor only works
+            // when the editor app is already open, but is favorable because it can
+            // open a code file on a specific line & column.
+            .catch(err => open(absFilePath))
+            .catch(err => res.status(500).send('Failed to open file'))
+            .then(() => res.send());
+    });
+}
+function getReqQuery(req) {
+    const { filePath, line, column } = req.query;
+    if (typeof filePath !== 'string')
+        throw new Error('filePath missing');
+    return {
+        filePath,
+        line: typeof line === 'string' ? parseInt(line, 10) : 1,
+        column: typeof column === 'string' ? parseInt(column, 10) : 1,
+    };
+}
+function resolveFilePath(rootDir, filePath) {
+    // This heuristic is needed because the open file endpoint is used for
+    // multiple applications, which provide different file path types:
+    // 1. Edit fixture button: Sends path relative to Cosmos rootDir
+    // 2. react-error-overlay runtime error: Sends absolute path
+    // 3. react-error-overlay compile error: Sends path relative to CWD
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    const cosmosRelPath = path.join(rootDir, filePath);
+    const cwdRelPath = path.join(process.cwd(), filePath);
+    return fs.existsSync(cosmosRelPath) ? cosmosRelPath : cwdRelPath;
+}

package/dist/server/devServer/corePlugins/pluginEndpoint.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../../cosmosPlugin/types.js';
+export default function pluginEndpointDevServerPlugin({ cosmosConfig, expressApp, }: DevServerPluginArgs): void;

package/dist/server/devServer/corePlugins/pluginEndpoint.js

@@ -0,0 +1,17 @@
+import { resolveFromSilent, resolveSilent } from '../../utils/resolveSilent.js';
+export default function pluginEndpointDevServerPlugin({ cosmosConfig, expressApp, }) {
+    expressApp.get('/_plugin/*.js', (req, res) => {
+        const moduleId = req.params['0'];
+        if (!moduleId) {
+            res.sendStatus(404);
+            return;
+        }
+        const resolvedPath = resolveSilent(`/${moduleId}`) ||
+            resolveFromSilent(cosmosConfig.rootDir, moduleId);
+        if (!resolvedPath) {
+            res.sendStatus(404);
+            return;
+        }
+        res.sendFile(resolvedPath);
+    });
+}

package/dist/server/devServer/corePlugins/userDepsFile.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../../cosmosPlugin/types.js';
+export declare function userDepsFileDevServerPlugin(args: DevServerPluginArgs): Promise<(() => void) | undefined>;