react-cosmos 5.7.2 → 6.0.0-alpha.0

package/dist/server/testHelpers/mockConsole.js

@@ -0,0 +1,11 @@
+export async function mockConsole(cb) {
+    const origConsoleLog = console.log;
+    console.log = jest.fn();
+    const expectedLogs = [];
+    const ret = await cb({
+        expectLog: (msg) => expectedLogs.push(msg),
+    });
+    expectedLogs.forEach(msg => expect(console.log).toBeCalledWith(msg));
+    console.log = origConsoleLog;
+    return ret;
+}

package/dist/server/testHelpers/mockEsmRequire.js

@@ -0,0 +1,13 @@
+jest.mock('../utils/requireModule.js', () => {
+    function requireModule(moduleId) {
+        return require(moduleId);
+    }
+    function requireFrom(fromDirectory, moduleId) {
+        return require(require.resolve(moduleId, { paths: [fromDirectory] }));
+    }
+    return {
+        requireModule,
+        requireFrom,
+    };
+});
+export {};

package/dist/server/testHelpers/mockEsmResolve.d.ts

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

package/dist/server/testHelpers/mockEsmResolve.js

@@ -0,0 +1,13 @@
+jest.mock('../utils/resolve.js', () => {
+    function resolve(moduleId) {
+        return require.resolve(moduleId);
+    }
+    function resolveFrom(fromDirectory, moduleId) {
+        return require.resolve(moduleId, { paths: [fromDirectory] });
+    }
+    return {
+        resolve,
+        resolveFrom,
+    };
+});
+export {};

package/dist/server/testHelpers/mockEsmStaticPath.d.ts

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

package/dist/server/testHelpers/mockEsmStaticPath.js

@@ -0,0 +1,7 @@
+jest.mock('../shared/staticPath.js', () => {
+    function getStaticPath(relPath) {
+        return require.resolve(`../static/${relPath}`);
+    }
+    return { getStaticPath };
+});
+export {};

package/dist/server/testHelpers/mockFetch.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="jest" />
+export declare function mockFetch(httpStatus: number, cb: (fetchMock: jest.Mock) => Promise<unknown>): Promise<void>;

package/dist/server/testHelpers/mockFetch.js

@@ -0,0 +1,7 @@
+export async function mockFetch(httpStatus, cb) {
+    const w = window;
+    const origFetch = window.fetch;
+    w.fetch = jest.fn(async () => ({ status: httpStatus }));
+    await cb(w.fetch);
+    w.fetch = origFetch;
+}

package/dist/server/testHelpers/mockFs.d.ts

@@ -0,0 +1,5 @@
+import { CosmosConfig } from '../cosmosConfig/types.js';
+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 resetFsMock(): void;

package/dist/server/testHelpers/mockFs.js

@@ -0,0 +1,64 @@
+import path from 'path';
+import { getCwdPath } from './cwd.js';
+jest.mock('../utils/fs', () => {
+    const actual = jest.requireActual('../utils/fs');
+    let mocked = false;
+    let fileMocks = {};
+    let dirMocks = [];
+    async function importModule(moduleId) {
+        if (!mocked)
+            return actual.importModule(moduleId);
+        return fileMocks[moduleId] || fileMocks[`${moduleId}.js`];
+    }
+    function moduleExists(moduleId) {
+        if (!mocked)
+            return actual.moduleExists(moduleId);
+        return (fileMocks.hasOwnProperty(moduleId) ||
+            fileMocks.hasOwnProperty(`${moduleId}.js`));
+    }
+    function fileExists(filePath) {
+        if (!mocked)
+            return actual.fileExists(filePath);
+        return fileMocks.hasOwnProperty(filePath);
+    }
+    function dirExists(dirPath) {
+        if (!mocked)
+            return actual.dirExists(dirPath);
+        return dirMocks.indexOf(dirPath) !== -1;
+    }
+    return {
+        importModule,
+        moduleExists,
+        fileExists,
+        dirExists,
+        __mockFile(filePath, fileMock) {
+            mocked = true;
+            fileMocks = { ...fileMocks, [filePath]: fileMock };
+        },
+        __mockDir(dirPath) {
+            mocked = true;
+            dirMocks = [...dirMocks, dirPath];
+        },
+        __resetMock() {
+            fileMocks = {};
+            dirMocks = [];
+        },
+    };
+});
+export function mockCosmosConfig(cosmosConfigPath, cosmosConfig) {
+    mockFile(cosmosConfigPath, cosmosConfig);
+}
+export function mockFile(filePath, fileContent) {
+    const absPath = getCwdPath(filePath);
+    requireMocked().__mockFile(absPath, fileContent);
+    requireMocked().__mockDir(path.dirname(absPath));
+}
+export function mockDir(dirPath) {
+    requireMocked().__mockDir(getCwdPath(dirPath));
+}
+export function resetFsMock() {
+    requireMocked().__resetMock();
+}
+function requireMocked() {
+    return require('../utils/fs.js');
+}

package/dist/server/testHelpers/mockYargs.d.ts

@@ -0,0 +1,2 @@
+export declare function mockCliArgs(cliArgs: {}): void;
+export declare function unmockCliArgs(): void;

package/dist/server/testHelpers/mockYargs.js

@@ -0,0 +1,21 @@
+// Secondary role of mocking yargs: Prevent Cosmos from intercepting the
+// --config arg passed to Jest
+jest.mock('yargs/yargs', () => {
+    let argv = {};
+    const yargs = () => ({
+        parseSync: () => argv,
+    });
+    yargs.__mockArgsv = (newArgv) => {
+        argv = newArgv;
+    };
+    return yargs;
+});
+export function mockCliArgs(cliArgs) {
+    requireMocked().__mockArgsv(cliArgs);
+}
+export function unmockCliArgs() {
+    requireMocked().__mockArgsv({});
+}
+function requireMocked() {
+    return require('yargs/yargs');
+}

package/dist/{userDeps → server/userDeps}/findUserModulePaths.d.ts

@@ -1,9 +1,9 @@
-declare type FindUserModulePathsArgs = {
+type FindUserModulePathsArgs = {
     rootDir: string;
     fixturesDir: string;
     fixtureFileSuffix: string;
 };
-declare type UserModulePaths = {
+type UserModulePaths = {
     fixturePaths: string[];
     decoratorPaths: string[];
 };

package/dist/server/userDeps/findUserModulePaths.js

@@ -0,0 +1,20 @@
+import glob from 'glob';
+import micromatch from 'micromatch';
+import { getDecoratorPatterns, getFixturePatterns, getIgnorePatterns, } from './shared.js';
+export function findUserModulePaths({ rootDir, fixturesDir, fixtureFileSuffix, }) {
+    const paths = glob.sync('**/*', {
+        cwd: rootDir,
+        absolute: true,
+        ignore: getIgnorePatterns(),
+    });
+    const fixturePatterns = getFixturePatterns(fixturesDir, fixtureFileSuffix);
+    const fixturePaths = getMatchingPaths(paths, fixturePatterns);
+    const decoratorPaths = getMatchingPaths(paths, getDecoratorPatterns());
+    // Omit decorators from fixture paths, which happens when decorators are
+    // placed inside fixture dirs.
+    const nonDecoratorFixturePaths = fixturePaths.filter(fixturePath => decoratorPaths.indexOf(fixturePath) === -1);
+    return { fixturePaths: nonDecoratorFixturePaths, decoratorPaths };
+}
+function getMatchingPaths(paths, patterns) {
+    return micromatch(paths, patterns, { dot: true });
+}

package/dist/server/userDeps/fixtureWatcher.d.ts

@@ -0,0 +1,3 @@
+import { FSWatcher } from 'chokidar';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+export declare function startFixtureWatcher(cosmosConfig: CosmosConfig, event: 'all' | 'add', callback: () => unknown): Promise<FSWatcher>;

package/dist/server/userDeps/fixtureWatcher.js

@@ -0,0 +1,20 @@
+import { watch } from 'chokidar';
+import { debounce } from 'lodash-es';
+import { getDecoratorPatterns, getFixturePatterns, getIgnorePatterns, } from './shared.js';
+const DEBOUNCE_INTERVAL = 50;
+export async function startFixtureWatcher(cosmosConfig, event, callback) {
+    const { fixturesDir, fixtureFileSuffix } = cosmosConfig;
+    const FILE_PATTERNS = [
+        ...getFixturePatterns(fixturesDir, fixtureFileSuffix),
+        ...getDecoratorPatterns(),
+    ];
+    return new Promise(resolve => {
+        const watcher = watch(FILE_PATTERNS, {
+            ignored: getIgnorePatterns(),
+            ignoreInitial: true,
+            cwd: cosmosConfig.rootDir,
+        })
+            .on('ready', () => resolve(watcher))
+            .on(event, debounce(() => callback(), DEBOUNCE_INTERVAL));
+    });
+}

package/dist/{userDeps → server/userDeps}/generateUserDepsModule.d.ts

@@ -1,6 +1,6 @@
-import { CosmosConfig } from '../config/shared';
-import { Json } from './shared';
-declare type Args = {
+import { CosmosConfig } from '../cosmosConfig/types.js';
+import { Json } from './shared.js';
+type Args = {
     cosmosConfig: CosmosConfig;
     rendererConfig: Json;
     relativeToDir: string | null;

package/dist/server/userDeps/generateUserDepsModule.js

@@ -0,0 +1,18 @@
+import { findUserModulePaths } from './findUserModulePaths.js';
+import { userDepsTemplate } from './userDepsTemplate.js';
+export function generateUserDepsModule({ cosmosConfig, rendererConfig, relativeToDir, }) {
+    const { rootDir, fixturesDir, fixtureFileSuffix, globalImports } = cosmosConfig;
+    const { fixturePaths, decoratorPaths } = findUserModulePaths({
+        rootDir,
+        fixturesDir,
+        fixtureFileSuffix,
+    });
+    return userDepsTemplate({
+        globalImports,
+        fixturePaths,
+        decoratorPaths,
+        rendererConfig,
+        rootDir,
+        relativeToDir,
+    });
+}

package/dist/{userDeps → server/userDeps}/getUserModules.d.ts

@@ -1,6 +1,6 @@
-import { ReactDecorators, ReactFixtureExports } from 'react-cosmos-shared2/react';
-import { CosmosConfig } from '../config/shared';
-declare type UserModules = {
+import { ReactDecorators, ReactFixtureExports } from 'react-cosmos-core';
+import { CosmosConfig } from '../cosmosConfig/types.js';
+type UserModules = {
     fixtures: ReactFixtureExports;
     decorators: ReactDecorators;
 };

package/dist/server/userDeps/getUserModules.js

@@ -0,0 +1,25 @@
+import path from 'path';
+import { slash } from '../utils/slash.js';
+import { findUserModulePaths } from './findUserModulePaths.js';
+export function getUserModules({ rootDir, fixturesDir, fixtureFileSuffix, }) {
+    const { fixturePaths, decoratorPaths } = findUserModulePaths({
+        rootDir,
+        fixturesDir,
+        fixtureFileSuffix,
+    });
+    return {
+        fixtures: getDefaultExports(fixturePaths, rootDir),
+        decorators: getDefaultExports(decoratorPaths, rootDir),
+    };
+}
+function getDefaultExports(paths, rootDir) {
+    const exportsByPath = {};
+    paths.forEach(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));
+        exportsByPath[relPath] = require(p).default;
+    });
+    return exportsByPath;
+}

package/dist/{userDeps → server/userDeps}/shared.d.ts

@@ -1,4 +1,4 @@
-export declare type Json = string | number | boolean | null | {
+export type Json = string | number | boolean | null | {
     [property: string]: Json;
 } | Json[];
 export declare function getFixturePatterns(fixturesDir: string, fixtureFileSuffix: string): string[];

package/dist/server/userDeps/shared.js

@@ -0,0 +1,20 @@
+import { replaceKeys } from 'react-cosmos-core';
+// NODE: These can be made configurable if a proper need arises
+const FIXTURE_PATTERNS = [
+    '**/<fixturesDir>/**/*.{js,jsx,ts,tsx}',
+    '**/*.<fixtureFileSuffix>.{js,jsx,ts,tsx}',
+];
+const DECORATOR_PATTERNS = ['**/cosmos.decorator.{js,jsx,ts,tsx}'];
+const IGNORE_PATTERNS = ['**/node_modules/**'];
+export function getFixturePatterns(fixturesDir, fixtureFileSuffix) {
+    return FIXTURE_PATTERNS.map(pattern => replaceKeys(pattern, {
+        '<fixturesDir>': fixturesDir,
+        '<fixtureFileSuffix>': fixtureFileSuffix,
+    }));
+}
+export function getDecoratorPatterns() {
+    return DECORATOR_PATTERNS;
+}
+export function getIgnorePatterns() {
+    return IGNORE_PATTERNS;
+}

package/dist/{userDeps → server/userDeps}/userDepsTemplate.d.ts

@@ -1,5 +1,5 @@
-import { Json } from './shared';
-declare type Args = {
+import { Json } from './shared.js';
+type Args = {
     globalImports: string[];
     fixturePaths: string[];
     decoratorPaths: string[];

package/dist/server/userDeps/userDepsTemplate.js

@@ -0,0 +1,49 @@
+import path from 'path';
+import { slash } from '../utils/slash.js';
+export function userDepsTemplate({ globalImports, fixturePaths, decoratorPaths, rendererConfig, rootDir, relativeToDir, }) {
+    const fixtures = createImportMap(fixturePaths, rootDir, relativeToDir);
+    const fixtureKeys = Object.keys(fixtures);
+    const decorators = createImportMap(decoratorPaths, rootDir, relativeToDir);
+    const decoratorKeys = Object.keys(decorators);
+    return `
+// This file is automatically generated by Cosmos. Add it to .gitignore and
+// only edit if you know what you're doing.
+
+// Keeping global imports here is superior to making them bundle entry points
+// because this way they become hot-reloadable.
+${globalImports
+        .map(p => `import '${resolveImportPath(p, relativeToDir)}';`)
+        .join(`\n`)}
+
+${fixtureKeys
+        .map((k, i) => `import fixture${i} from '${fixtures[k]}';`)
+        .join(`\n`)}
+
+${decoratorKeys
+        .map((k, i) => `import decorator${i} from '${decorators[k]}';`)
+        .join(`\n`)}
+
+export const rendererConfig = ${JSON.stringify(rendererConfig, null, 2)};
+
+export const fixtures = {
+${fixtureKeys
+        .map((k, i) => `  '${k}': { module: { default: fixture${i} } }`)
+        .join(`,\n`)}
+};
+
+export const decorators = {
+${decoratorKeys.map((k, i) => `  '${k}': decorator${i}`).join(`,\n`)}
+};
+`.trimStart();
+}
+function createImportMap(paths, rootDir, relativeToDir) {
+    return paths.reduce((acc, p) => ({
+        ...acc,
+        [slash(path.relative(rootDir, p))]: resolveImportPath(p, relativeToDir),
+    }), {});
+}
+function resolveImportPath(filePath, relativeToDir) {
+    return slash(relativeToDir
+        ? `.${path.sep}${path.relative(relativeToDir, filePath)}`
+        : filePath);
+}

package/dist/server/utils/cli.js

@@ -0,0 +1,4 @@
+import yargs from 'yargs/yargs';
+export function getCliArgs() {
+    return yargs(process.argv.slice(2)).parseSync();
+}

package/dist/server/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function importModule<T>(moduleId: string): Promise<T>;
+export declare function moduleExists(moduleId: string): boolean | "";
+export declare function fileExists(filePath: string): boolean;
+export declare function dirExists(dirPath: string): boolean;

package/dist/server/utils/fs.js

@@ -0,0 +1,24 @@
+// NOTE: This API has been extracted to easily mock the file system in tests
+import fs from 'fs';
+import { requireModule } from './requireModule.js';
+import { resolve } from './resolve.js';
+export async function importModule(moduleId) {
+    return moduleId.endsWith('.json')
+        ? requireModule(moduleId)
+        : import(moduleId);
+}
+// Better than fs.exists because it works for module paths without an extension
+export function moduleExists(moduleId) {
+    try {
+        return resolve(moduleId) && true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+export function fileExists(filePath) {
+    return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+}
+export function dirExists(dirPath) {
+    return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+}

package/dist/server/utils/isNodeError.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function isNodeError(err: any): err is NodeJS.ErrnoException;

package/dist/server/utils/isNodeError.js

@@ -0,0 +1,3 @@
+export function isNodeError(err) {
+    return err && err.stack && err.message;
+}

package/dist/server/utils/requireModule.d.ts

@@ -0,0 +1,2 @@
+export declare function requireModule(moduleId: string): any;
+export declare function requireFrom(fromDirectory: string, moduleId: string): any;

package/dist/server/utils/requireModule.js

@@ -0,0 +1,13 @@
+import { createRequire } from 'node:module';
+import path from 'path';
+// NOTE: This is ESM code that can't run in Jest yet, which means that this
+// module always needs to be mocked in tests until Jest adds ESM support.
+export function requireModule(moduleId) {
+    const require = createRequire(import.meta.url);
+    return require(moduleId);
+}
+export function requireFrom(fromDirectory, moduleId) {
+    // Inspired by https://github.com/sindresorhus/import-from
+    const require = createRequire(path.resolve(fromDirectory, 'noop.js'));
+    return require(moduleId);
+}

package/dist/server/utils/requireSilent.d.ts

@@ -0,0 +1 @@
+export declare function requireFromSilent(fromDirectory: string, moduleId: string): any;

package/dist/server/utils/requireSilent.js

@@ -0,0 +1,11 @@
+import { isNodeError } from './isNodeError.js';
+import { requireFrom } from './requireModule.js';
+export function requireFromSilent(fromDirectory, moduleId) {
+    try {
+        return requireFrom(fromDirectory, moduleId);
+    }
+    catch (err) {
+        if (!isNodeError(err) || err.code !== 'MODULE_NOT_FOUND')
+            console.log(err);
+    }
+}

package/dist/server/utils/resolve.d.ts

@@ -0,0 +1,2 @@
+export declare function resolve(moduleId: string): string;
+export declare function resolveFrom(fromDirectory: string, moduleId: string): string;

package/dist/server/utils/resolve.js

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';
+// NOTE: This is ESM code that can't run in Jest yet, which means that this
+// module always needs to be mocked in tests until Jest adds ESM support.
+// One day this code will be replaced by import.meta.resolve
+// https://nodejs.org/api/esm.html#importmetaresolvespecifier-parent
+// Still under --experimental-import-meta-resolve flag in Node v19
+export function resolve(moduleId) {
+    const require = createRequire(import.meta.url);
+    return require.resolve(moduleId);
+}
+export function resolveFrom(fromDirectory, moduleId) {
+    const require = createRequire(import.meta.url);
+    return require.resolve(moduleId, { paths: [fromDirectory] });
+}

package/dist/server/utils/resolveLoose.d.ts

@@ -0,0 +1 @@
+export declare function resolveLoose(fromDirectory: string, moduleId: string): string;

package/dist/server/utils/resolveLoose.js

@@ -0,0 +1,12 @@
+import path from 'path';
+import { resolveFromSilent } from './resolveSilent.js';
+export function resolveLoose(fromDirectory, moduleId) {
+    // Use to deal with file paths and module names interchangeably.
+    return path.isAbsolute(moduleId)
+        ? moduleId
+        : resolveFromSilent(fromDirectory, moduleId) ||
+            // Final attempt: Resolve relative paths that don't either
+            // 1. Don't start with ./
+            // 2. Don't point to an existing file
+            path.join(fromDirectory, moduleId);
+}

package/dist/server/utils/resolveSilent.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveSilent(moduleId: string): string | null;
+export declare function resolveFromSilent(fromDirectory: string, moduleId: string): string | null;

package/dist/server/utils/resolveSilent.js

@@ -0,0 +1,22 @@
+import { isNodeError } from './isNodeError.js';
+import { resolve, resolveFrom } from './resolve.js';
+export function resolveSilent(moduleId) {
+    try {
+        return resolve(moduleId);
+    }
+    catch (err) {
+        if (!isNodeError(err) || err.code !== 'MODULE_NOT_FOUND')
+            console.log(err);
+        return null;
+    }
+}
+export function resolveFromSilent(fromDirectory, moduleId) {
+    try {
+        return resolveFrom(fromDirectory, moduleId);
+    }
+    catch (err) {
+        if (!isNodeError(err) || err.code !== 'MODULE_NOT_FOUND')
+            console.log(err);
+        return null;
+    }
+}

package/dist/server/utils/slash.d.ts

@@ -0,0 +1 @@
+export declare function slash(path: string): string;

package/dist/server/utils/slash.js

@@ -0,0 +1,5 @@
+// Copied from https://github.com/sindresorhus/slash/blob/205c404ecf35b7a7a8a687d8d3b79101aaaa9fba/index.js
+export function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    return isExtendedLengthPath ? path : path.replace(/\\/g, '/');
+}

package/dist/server.d.ts

@@ -0,0 +1,20 @@
+export * from './server/cosmosConfig/createCosmosConfig.js';
+export * from './server/cosmosConfig/detectCosmosConfig.js';
+export * from './server/cosmosConfig/getCosmosConfigAtPath.js';
+export * from './server/cosmosConfig/types.js';
+export * from './server/cosmosPlugin/findCosmosPluginConfigs.js';
+export * from './server/cosmosPlugin/pluginConfigs.js';
+export * from './server/cosmosPlugin/types.js';
+export * from './server/getFixtures/getFixtures.js';
+export { RENDERER_FILENAME } from './server/shared/playgroundHtml.js';
+export * from './server/shared/playgroundUrl.js';
+export * from './server/shared/staticServer.js';
+export * from './server/testHelpers/cwd.js';
+export * from './server/userDeps/fixtureWatcher.js';
+export * from './server/userDeps/generateUserDepsModule.js';
+export * from './server/utils/cli.js';
+export * from './server/utils/fs.js';
+export * from './server/utils/requireSilent.js';
+export * from './server/utils/resolve.js';
+export * from './server/utils/resolveLoose.js';
+export * from './server/utils/resolveSilent.js';

package/dist/server.js

@@ -0,0 +1,20 @@
+export * from './server/cosmosConfig/createCosmosConfig.js';
+export * from './server/cosmosConfig/detectCosmosConfig.js';
+export * from './server/cosmosConfig/getCosmosConfigAtPath.js';
+export * from './server/cosmosConfig/types.js';
+export * from './server/cosmosPlugin/findCosmosPluginConfigs.js';
+export * from './server/cosmosPlugin/pluginConfigs.js';
+export * from './server/cosmosPlugin/types.js';
+export * from './server/getFixtures/getFixtures.js';
+export { RENDERER_FILENAME } from './server/shared/playgroundHtml.js';
+export * from './server/shared/playgroundUrl.js';
+export * from './server/shared/staticServer.js';
+export * from './server/testHelpers/cwd.js';
+export * from './server/userDeps/fixtureWatcher.js';
+export * from './server/userDeps/generateUserDepsModule.js';
+export * from './server/utils/cli.js';
+export * from './server/utils/fs.js';
+export * from './server/utils/requireSilent.js';
+export * from './server/utils/resolve.js';
+export * from './server/utils/resolveLoose.js';
+export * from './server/utils/resolveSilent.js';

package/index.d.ts

@@ -1 +1 @@
-export * from './dist/index';
+export * from './dist/index.js';

package/index.js

@@ -1,2 +1 @@
-require('regenerator-runtime/runtime');
-module.exports = require('./dist/index');
+export * from './dist/index.js';

package/jest.d.ts

@@ -0,0 +1 @@
+export * from './dist/jest.js';

package/jest.js

@@ -0,0 +1 @@
+module.exports = require('./dist/jest.js');