happy-css-modules 0.2.0

package/src/resolver/relative-resolver.test.ts

@@ -0,0 +1,13 @@
+import { getFixturePath } from '../test/util.js';
+import { createRelativeResolver } from './relative-resolver.js';
+
+const relativeResolver = createRelativeResolver();
+const request = getFixturePath('/test/1.css');
+
+test('resolves specifier with relative mechanism', async () => {
+  expect(await relativeResolver('2.css', { request })).toBe(getFixturePath('/test/2.css'));
+  expect(await relativeResolver('./3.css', { request })).toBe(getFixturePath('/test/3.css'));
+  expect(await relativeResolver('dir/4.css', { request })).toBe(getFixturePath('/test/dir/4.css'));
+  expect(await relativeResolver('../5.css', { request })).toBe(getFixturePath('/5.css'));
+  expect(await relativeResolver(getFixturePath('/test/6.css'), { request })).toBe(getFixturePath('/test/6.css'));
+});

package/src/resolver/relative-resolver.ts

@@ -0,0 +1,6 @@
+import { dirname, resolve } from 'path';
+import type { Resolver } from './index.js';
+
+export const createRelativeResolver: () => Resolver = () => (specifier, options) => {
+  return resolve(dirname(options.request), specifier);
+};

package/src/resolver/webpack-resolver.test.ts

@@ -0,0 +1,33 @@
+import { createFixtures, getFixturePath } from '../test/util.js';
+import { createWebpackResolver } from './webpack-resolver.js';
+
+const webpackResolver = createWebpackResolver();
+const request = getFixturePath('/test/1.css');
+
+test('resolves specifier with webpack mechanism', async () => {
+  createFixtures({
+    '/node_modules/package-1/index.css': `.a {}`,
+    '/node_modules/package-2/index.css': `.a {}`,
+    '/node_modules/package-3/index.css': `.a {}`,
+    '/node_modules/package-4/package.json': `{ "style": "./style.css" }`,
+    '/node_modules/package-4/style.css': `.a {}`,
+    '/node_modules/@scoped/package-5/index.css': `.a {}`,
+    '/node_modules/package-6/index.css': `.a {}`,
+    '/node_modules/package-7/index.scss': `.a { dummy: ''; }`,
+    '/node_modules/package-8/index.less': `.a { dummy: ''; }`,
+  });
+  expect(await webpackResolver('~package-1/index.css', { request })).toBe(
+    getFixturePath('/node_modules/package-1/index.css'),
+  );
+  expect(await webpackResolver('~package-2', { request })).toBe(getFixturePath('/node_modules/package-2/index.css'));
+  expect(await webpackResolver('~package-3/', { request })).toBe(getFixturePath('/node_modules/package-3/index.css'));
+  expect(await webpackResolver('~package-4', { request })).toBe(getFixturePath('/node_modules/package-4/style.css'));
+  expect(await webpackResolver('~@scoped/package-5/index.css', { request })).toBe(
+    getFixturePath('/node_modules/@scoped/package-5/index.css'),
+  );
+  expect(await webpackResolver('package-6/index.css', { request })).toBe(
+    getFixturePath('/node_modules/package-6/index.css'),
+  );
+  expect(await webpackResolver('~package-7', { request })).toBe(getFixturePath('/node_modules/package-7/index.scss'));
+  expect(await webpackResolver('~package-8', { request })).toBe(getFixturePath('/node_modules/package-8/index.less'));
+});

package/src/resolver/webpack-resolver.ts

@@ -0,0 +1,71 @@
+import { dirname } from 'path';
+import enhancedResolve from 'enhanced-resolve';
+import { exists } from '../util.js';
+import type { Resolver } from './index.js';
+
+/**
+ * A resolver compatible with css-loader.
+ *
+ * @see https://github.com/webpack-contrib/css-loader/blob/897e7dd250ccdb0d31e6c66d4cd0d009f2022a85/src/plugins/postcss-import-parser.js#L228-L235
+ */
+const cssLoaderResolver = enhancedResolve.create.sync({
+  dependencyType: 'css',
+  conditionNames: ['style'],
+  // We are not sure how "..." affects behavior...
+  mainFields: ['css', 'style', 'main', '...'],
+  mainFiles: ['index', '...'],
+  extensions: ['.css', '...'],
+  preferRelative: true,
+});
+
+/**
+ * A resolver compatible with sass-loader.
+ *
+ * @see https://github.com/webpack-contrib/sass-loader/blob/49a578a218574ddc92a597c7e365b6c21960717e/src/utils.js#L531-L539
+ */
+const sassLoaderResolver = enhancedResolve.create.sync({
+  dependencyType: 'sass',
+  conditionNames: ['sass', 'style'],
+  mainFields: ['sass', 'style', 'main', '...'],
+  mainFiles: ['_index', 'index', '...'],
+  extensions: ['.sass', '.scss', '.css'],
+  restrictions: [/\.((sa|sc|c)ss)$/i],
+  preferRelative: true,
+});
+
+/**
+ * A resolver compatible with less-loader.
+ *
+ * @see https://github.com/webpack-contrib/less-loader/blob/d74f740c100c4006b00dfb3e02c6d5aaf8713519/src/utils.js#L35-L42
+ */
+const lessLoaderResolver = enhancedResolve.create.sync({
+  dependencyType: 'less',
+  conditionNames: ['less', 'style'],
+  mainFields: ['less', 'style', 'main', '...'],
+  mainFiles: ['index', '...'],
+  extensions: ['.less', '.css'],
+  preferRelative: true,
+});
+
+// TODO: Support `resolve.alias` for Node.js API
+export const createWebpackResolver: () => Resolver = () => async (specifier, options) => {
+  // `~` prefix is optional.
+  // ref: https://github.com/webpack-contrib/less-loader/tree/454e187f58046356c3d383d67fda763db8bfc528#webpack-resolver
+  if (specifier.startsWith('~')) specifier = specifier.slice(1);
+
+  // NOTE: In theory, `sassLoaderResolver` should only be used when the resolver is called from `sassTransformer`.
+  // However, we do not implement such behavior because it is cumbersome. If someone wants it, we will implement it.
+  const resolvers = [cssLoaderResolver, sassLoaderResolver, lessLoaderResolver];
+  for (const resolver of resolvers) {
+    try {
+      const resolved = resolver(dirname(options.request), specifier);
+      if (resolved !== false) {
+        const isExists = await exists(resolved);
+        if (isExists) return resolved;
+      }
+    } catch (e) {
+      // noop
+    }
+  }
+  return false;
+};

package/src/runner.test.ts

@@ -0,0 +1,122 @@
+import { readFile, writeFile } from 'fs/promises';
+import { jest } from '@jest/globals';
+import chalk from 'chalk';
+import dedent from 'dedent';
+import AggregateError from 'es-aggregate-error';
+import { run } from './runner.js';
+import { createFixtures, exists, getFixturePath, waitForAsyncTask } from './test/util.js';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+const defaultOptions = {
+  pattern: 'test/**/*.{css,scss}',
+  declarationMap: true,
+  silent: true,
+  cwd: getFixturePath('/'),
+};
+
+test('generates .d.ts and .d.ts.map', async () => {
+  createFixtures({
+    '/test/1.css': '.a {}',
+    '/test/2.css': '.b {}',
+  });
+  await run({ ...defaultOptions });
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatchSnapshot();
+  expect(await readFile(getFixturePath('/test/1.css.d.ts.map'), 'utf8')).toMatchSnapshot();
+  expect(await readFile(getFixturePath('/test/2.css.d.ts'), 'utf8')).toMatchSnapshot();
+  expect(await readFile(getFixturePath('/test/2.css.d.ts.map'), 'utf8')).toMatchSnapshot();
+});
+
+test.todo('changes dts format with localsConvention options');
+test('does not emit declaration map if declarationMap is false', async () => {
+  createFixtures({
+    '/test/1.css': '.a {}',
+  });
+  await run({ ...defaultOptions, declarationMap: false });
+  await expect(readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).resolves.not.toThrow();
+  await expect(readFile(getFixturePath('/test/1.css.d.ts.map'), 'utf8')).rejects.toThrow(/ENOENT/);
+});
+test('supports transformer', async () => {
+  createFixtures({
+    '/test/1.scss': `.a { dummy: ''; }`,
+  });
+  await run({ ...defaultOptions });
+  expect(await readFile(getFixturePath('/test/1.scss.d.ts'), 'utf8')).toMatchSnapshot();
+  expect(await readFile(getFixturePath('/test/1.scss.d.ts.map'), 'utf8')).toMatchSnapshot();
+});
+test('watches for changes in files', async () => {
+  createFixtures({
+    '/test': {}, // empty directory
+  });
+  const watcher = await run({ ...defaultOptions, watch: true });
+
+  await writeFile(getFixturePath('/test/1.css'), '.a-1 {}');
+  await waitForAsyncTask(500); // Wait until the file is written
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-1/);
+
+  await writeFile(getFixturePath('/test/1.css'), '.a-2 {}');
+  await waitForAsyncTask(500); // Wait until the file is written
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-2/);
+
+  await watcher.close();
+});
+test('returns an error if the file fails to process in non-watch mode', async () => {
+  createFixtures({
+    '/test/1.css': '.a {}',
+    '/test/2.css': 'INVALID SYNTAX',
+    '/test/3.css': 'INVALID SYNTAX',
+  });
+  const maybeError = await run({ ...defaultOptions, watch: false }).catch((e) => e);
+
+  // The errors are aggregated into AggregateError.
+  expect(maybeError).toBeInstanceOf(AggregateError);
+  const error = maybeError as AggregateError;
+  expect(error.message).toMatchInlineSnapshot(`"Failed to process files"`);
+  expect(error.errors).toHaveLength(2);
+  expect(error.errors[0]).toMatchInlineSnapshot(`<fixtures>/test/2.css:1:1: Unknown word`);
+  expect(error.errors[1]).toMatchInlineSnapshot(`<fixtures>/test/3.css:1:1: Unknown word`);
+
+  // The error is logged to console.error.
+  expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  expect(consoleErrorSpy).toHaveBeenNthCalledWith(1, chalk.red('[Error] ' + error.errors[0]));
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  expect(consoleErrorSpy).toHaveBeenNthCalledWith(2, chalk.red('[Error] ' + error.errors[1]));
+
+  // The valid files are emitted.
+  expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);
+  expect(await exists(getFixturePath('/test/1.css.d.ts.map'))).toBe(true);
+});
+describe('handles external files', () => {
+  beforeEach(() => {
+    createFixtures({
+      '/test/1.css': dedent`
+      @import './2.css';
+      @import 'external-library';
+      .a {}
+      `,
+      '/test/2.css': `.b {}`,
+      '/node_modules/external-library/index.css': `.c {}`,
+    });
+  });
+  test('do not emit .dts for external files', async () => {
+    await run({ ...defaultOptions });
+    expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);
+    expect(await exists(getFixturePath('/test/2.css.d.ts'))).toBe(true);
+    expect(await exists(getFixturePath('/node_modules/external-library/index.css.d.ts'))).toBe(false);
+  });
+  test('treats imported tokens from external files the same as local tokens', async () => {
+    await run({ ...defaultOptions });
+    expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatchInlineSnapshot(`
+    "declare const styles:
+      & Readonly<Pick<(typeof import("./2.css"))["default"], "b">>
+      & Readonly<{ "c": string }>
+      & Readonly<{ "a": string }>
+    ;
+    export default styles;
+    //# sourceMappingURL=./1.css.d.ts.map
+    "
+  `);
+  });
+});

package/src/runner.ts

@@ -0,0 +1,105 @@
+import { resolve } from 'path';
+import * as process from 'process';
+import * as util from 'util';
+import chalk from 'chalk';
+import * as chokidar from 'chokidar';
+import AggregateError from 'es-aggregate-error';
+import _glob from 'glob';
+import { emitGeneratedFiles } from './emitter/index.js';
+import { Loader } from './loader/index.js';
+import type { Resolver } from './resolver/index.js';
+import { type Transformer } from './transformer/index.js';
+import { isMatchByGlob } from './util.js';
+
+const glob = util.promisify(_glob);
+
+export type Watcher = {
+  close: () => Promise<void>;
+};
+
+export type LocalsConvention = 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | undefined;
+
+export interface RunnerOptions {
+  pattern: string;
+  outDir?: string | undefined;
+  watch?: boolean | undefined;
+  localsConvention?: LocalsConvention | undefined;
+  declarationMap?: boolean | undefined;
+  transformer?: Transformer | undefined;
+  resolver?: Resolver | undefined;
+  /**
+   * Silent output. Do not show "files written" messages.
+   * @default false
+   */
+  silent?: boolean | undefined;
+  /** Working directory path. */
+  cwd?: string | undefined;
+}
+
+type OverrideProp<T, K extends keyof T, V extends T[K]> = Omit<T, K> & { [P in K]: V };
+
+/**
+ * Run typed-css-module.
+ * @param options Runner options.
+ * @returns Returns `Promise<Watcher>` if `options.watch` is `true`, `Promise<void>` if `false`.
+ */
+export async function run(options: OverrideProp<RunnerOptions, 'watch', true>): Promise<Watcher>;
+export async function run(options: RunnerOptions): Promise<void>;
+export async function run(options: RunnerOptions): Promise<Watcher | void> {
+  const loader = new Loader({ transformer: options.transformer, resolver: options.resolver });
+  const distOptions = options.outDir
+    ? {
+        rootDir: process.cwd(), // TODO: support `--rootDir` option
+        outDir: options.outDir,
+      }
+    : undefined;
+  const isExternalFile = (filePath: string) => {
+    return !isMatchByGlob(filePath, options.pattern, { cwd: options.cwd ?? process.cwd() });
+  };
+
+  async function processFile(filePath: string) {
+    try {
+      const result = await loader.load(filePath);
+      await emitGeneratedFiles({
+        filePath,
+        tokens: result.tokens,
+        distOptions,
+        emitDeclarationMap: options.declarationMap,
+        dtsFormatOptions: {
+          localsConvention: options.localsConvention,
+        },
+        silent: options.silent ?? false,
+        cwd: options.cwd ?? process.cwd(),
+        isExternalFile,
+      });
+    } catch (error) {
+      // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+      console.error(chalk.red('[Error] ' + error));
+      throw error;
+    }
+  }
+
+  if (options.watch) {
+    if (!options.silent) console.log('Watch ' + options.pattern + '...');
+    const watcher = chokidar.watch([options.pattern.replace(/\\/g, '/')], options.cwd ? { cwd: options.cwd } : {});
+    watcher.on('all', (eventName, filePath) => {
+      if (eventName === 'add' || eventName === 'change') {
+        processFile(resolve(options.cwd ?? process.cwd(), filePath)).catch(() => {
+          // TODO: Emit a error by `Watcher#onerror`
+        });
+      }
+    });
+    return { close: async () => watcher.close() };
+  } else {
+    const filePaths = (await glob(options.pattern, { dot: true, cwd: options.cwd ?? process.cwd() }))
+      // convert relative path to absolute path
+      .map((file) => resolve(options.cwd ?? process.cwd(), file));
+
+    // TODO: Use `@file-cache/core` to process only files that have changed
+    const errors: unknown[] = [];
+    for (const filePath of filePaths) {
+      await processFile(filePath).catch((e: unknown) => errors.push(e));
+    }
+    if (errors.length > 0) throw new AggregateError(errors, 'Failed to process files');
+  }
+}

package/src/test/jest/resolver.cjs

@@ -0,0 +1,30 @@
+const nativeModule = require('node:module');
+
+// workaround for https://github.com/facebook/jest/issues/12270#issuecomment-1194746382
+
+/**
+ * @typedef {{
+ * basedir: string;
+ * conditions?: Array<string>;
+ * defaultResolver: (path: string, options: ResolverOptions) => string;
+ * extensions?: Array<string>;
+ * moduleDirectory?: Array<string>;
+ * paths?: Array<string>;
+ * packageFilter?: (pkg: any, file: string, dir: string) => any;
+ * pathFilter?: (pkg: any, path: string, relativePath: string) => string;
+ * rootDir?: string;
+ * }} ResolverOptions
+ * */
+
+/** @type {(path: string, options: ResolverOptions) => string} */
+function resolver(module, options) {
+  const { basedir, defaultResolver } = options;
+  try {
+    return defaultResolver(module, options);
+    // eslint-disable-next-line no-unused-vars
+  } catch (error) {
+    return nativeModule.createRequire(basedir).resolve(module);
+  }
+}
+
+module.exports = resolver;

package/src/test/tsserver.ts

@@ -0,0 +1,176 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import serverHarness from '@typescript/server-harness';
+import { resolve } from 'import-meta-resolve';
+import lineColumn from 'line-column';
+import { getFixturePath } from './util.js';
+
+// TODO: refactor this
+
+type Definition = {
+  /** The path of the destination file */
+  file: string;
+  /** The text at definition destination */
+  text: string;
+  /** inclusive */
+  start: {
+    /** line, 1-based */
+    line: number;
+    /** column, 1-based */
+    offset: number;
+  };
+  /** exclusive */
+  end: {
+    /** line, 1-based */
+    line: number;
+    /** column, 1-based */
+    offset: number;
+  };
+};
+
+type DefinitionResponse = {
+  seq: number;
+  type: 'response';
+  command: 'definition';
+  success: boolean;
+  body: [
+    {
+      /** The path of the destination file */
+      file: string;
+      /** inclusive */
+      start: {
+        /** line, 1-based */
+        line: number;
+        /** column, 1-based */
+        offset: number;
+      };
+      /** exclusive */
+      end: {
+        /** line, 1-based */
+        line: number;
+        /** column, 1-based */
+        offset: number;
+      };
+    },
+  ];
+};
+
+export async function getIdentifierDefinitions(filePath: string, identifier: string): Promise<Definition[]> {
+  const results = await getMultipleIdentifierDefinitions(filePath, [identifier]);
+  return results[0]!.definitions;
+}
+
+export async function getMultipleIdentifierDefinitions(
+  filePath: string,
+  identifiers: string[],
+): Promise<{ identifier: string; definitions: Definition[] }[]> {
+  const server = serverHarness.launchServer(
+    fileURLToPath(await resolve('typescript/lib/tsserver.js', import.meta.url)),
+    [
+      // ATA generates some extra network traffic and isn't usually relevant when profiling
+      '--disableAutomaticTypingAcquisition',
+    ],
+  );
+
+  const tmpFilePath = getFixturePath('/server-harness/tmp.ts');
+  const tmpFileContent = [
+    `import styles from '${filePath}';`,
+    ...identifiers.map((identifier) => `styles.${identifier};`),
+  ].join('\n');
+
+  await server.message({
+    type: 'request',
+    command: 'updateOpen',
+    arguments: {
+      changedFiles: [],
+      closedFiles: [],
+      openFiles: [
+        {
+          file: tmpFilePath,
+          fileContent: tmpFileContent,
+          projectRootPath: getFixturePath('/server-harness'),
+          scriptKindName: 'TS', // It's easy to get this wrong when copy-pasting
+        },
+      ],
+    },
+  });
+
+  const results: { identifier: string; definitions: Definition[] }[] = [];
+
+  for (let i = 0; i < identifiers.length; i++) {
+    const response: DefinitionResponse = await server.message({
+      type: 'request',
+      command: 'definition',
+      arguments: {
+        file: tmpFilePath,
+        line: i + 2, // line, 1-based
+        offset: 8, // column, 1-based
+      },
+    });
+    const definitions: Definition[] = response.body.map((definition) => {
+      const { file, start, end } = definition;
+      const fileContent = readFileSync(file, 'utf-8');
+      const startIndex = lineColumn(fileContent).toIndex(start.line, start.offset);
+      const endIndex = lineColumn(fileContent).toIndex(end.line, end.offset);
+      const text = fileContent.slice(startIndex, endIndex);
+      return { file, text, start, end };
+    });
+    results.push({ identifier: identifiers[i]!, definitions });
+  }
+
+  await server.message({ command: 'exit' });
+
+  return results;
+}
+
+export async function getModuleDefinitions(filePath: string): Promise<Definition[]> {
+  const server = serverHarness.launchServer(
+    fileURLToPath(await resolve('typescript/lib/tsserver.js', import.meta.url)),
+    [
+      // ATA generates some extra network traffic and isn't usually relevant when profiling
+      '--disableAutomaticTypingAcquisition',
+    ],
+  );
+
+  const tmpFilePath = getFixturePath('/server-harness/tmp.ts');
+  const tmpFileContent = `import styles from '${filePath}';`;
+
+  await server.message({
+    type: 'request',
+    command: 'updateOpen',
+    arguments: {
+      changedFiles: [],
+      closedFiles: [],
+      openFiles: [
+        {
+          file: tmpFilePath,
+          fileContent: tmpFileContent,
+          projectRootPath: getFixturePath('/server-harness'),
+          scriptKindName: 'TS', // It's easy to get this wrong when copy-pasting
+        },
+      ],
+    },
+  });
+
+  const response: DefinitionResponse = await server.message({
+    type: 'request',
+    command: 'definition',
+    arguments: {
+      file: tmpFilePath,
+      line: 1, // line, 1-based
+      offset: 20, // column, 1-based
+    },
+  });
+  const definitions: Definition[] = response.body.map((definition) => {
+    const { file, start, end } = definition;
+    const fileContent = readFileSync(file, 'utf-8');
+    const startIndex = lineColumn(fileContent).toIndex(start.line, start.offset);
+    const endIndex = lineColumn(fileContent).toIndex(end.line, end.offset);
+    const text = fileContent.slice(startIndex, endIndex);
+    return { file, text, start, end };
+  });
+
+  await server.message({ command: 'exit' });
+
+  return definitions;
+}

package/src/test/util.ts

@@ -0,0 +1,100 @@
+import { constants, mkdirSync, realpathSync, rmSync, writeFileSync } from 'fs';
+import { access } from 'fs/promises';
+import { tmpdir } from 'os';
+import { dirname, join, resolve } from 'path';
+import postcss, { type Root, type Rule, type AtRule, type Declaration } from 'postcss';
+import { type ClassName } from 'postcss-selector-parser';
+import { type Token, collectNodes, type Location } from '../loader/index.js';
+import { sleepSync } from '../util.js';
+
+export const FIXTURE_DIR_PATH = resolve(
+  realpathSync(tmpdir()),
+  'happy-css-modules/fixtures',
+  process.env['JEST_WORKER_ID']!,
+);
+
+export function createRoot(code: string, from?: string): Root {
+  return postcss.parse(code, { from: from || '/test/test.css' });
+}
+
+export function createAtImports(root: Root): AtRule[] {
+  return collectNodes(root).atImports;
+}
+
+export function createClassSelectors(root: Root): { rule: Rule; classSelector: ClassName }[] {
+  return collectNodes(root).classSelectors;
+}
+
+export function createComposesDeclarations(root: Root): Declaration[] {
+  return collectNodes(root).composesDeclarations;
+}
+
+export function fakeToken(args: {
+  name: Token['name'];
+  originalLocations: { filePath?: Location['filePath']; start: Location['start'] }[];
+}): Token {
+  return {
+    name: args.name,
+    originalLocations: args.originalLocations.map((location) => ({
+      filePath: location.filePath ?? getFixturePath('/test/1.css'),
+      start: location.start,
+      end: {
+        line: location.start.line,
+        column: location.start.column + args.name.length - 1,
+      },
+    })),
+  };
+}
+
+export async function waitForAsyncTask(ms?: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms ?? 0));
+}
+
+export async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+type File = string;
+
+type DirectoryItem = File | DirectoryItems;
+
+type DirectoryItems = {
+  [name: string]: DirectoryItem;
+};
+
+function isFile(item: DirectoryItem): item is File {
+  return typeof item === 'string';
+}
+
+export function createFixtures(items: DirectoryItems): void {
+  function createFixturesImpl(items: DirectoryItems, baseDir: string): void {
+    for (const [name, item] of Object.entries(items)) {
+      const path = join(baseDir, name);
+      if (isFile(item)) {
+        mkdirSync(dirname(path), { recursive: true });
+        if (typeof item === 'string') {
+          writeFileSync(path, item);
+        }
+      } else {
+        mkdirSync(path, { recursive: true });
+        createFixturesImpl(item, path);
+      }
+    }
+  }
+  removeFixtures();
+  sleepSync(2); // Wait 2 ms for mtime to change from the previous fixture.
+  createFixturesImpl(items, FIXTURE_DIR_PATH);
+}
+
+export function removeFixtures(): void {
+  rmSync(FIXTURE_DIR_PATH, { recursive: true, force: true });
+}
+
+export function getFixturePath(path: string): string {
+  return join(FIXTURE_DIR_PATH, path);
+}