creevey 0.9.0-non-webpack.2.fix-capture-element → 0.9.0

package/src/server/selenium/index.ts

@@ -0,0 +1,2 @@
+export * from './browser.js';
+export * from './selenoid.js';

package/src/server/selenium/selenoid.ts

@@ -0,0 +1,154 @@
+import path from 'path';
+import assert from 'assert';
+import cluster from 'cluster';
+import { lstatSync, existsSync } from 'fs';
+import { mkdir, writeFile, copyFile } from 'fs/promises';
+import sh from 'shelljs';
+import { Octokit } from '@octokit/core';
+import { Config, BrowserConfig } from '../../types.js';
+import { downloadBinary, getCreeveyCache } from '../utils.js';
+import { pullImages, runImage } from '../docker.js';
+import { subscribeOn } from '../messages.js';
+
+async function createSelenoidConfig(browsers: BrowserConfig[], { useDocker }: { useDocker: boolean }): Promise<string> {
+  const selenoidConfig: Partial<
+    Record<
+      string,
+      {
+        default: string;
+        versions: Record<string, { image: string | string[]; port: string; path: string }>;
+      }
+    >
+  > = {};
+  const cacheDir = getCreeveyCache();
+
+  assert(cacheDir, "Couldn't get cache directory");
+
+  const selenoidConfigDir = path.join(cacheDir, 'selenoid');
+
+  browsers.forEach(
+    ({
+      browserName,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      version = 'latest',
+      browserVersion = version,
+      dockerImage = `selenoid/${browserName}:${browserVersion}`,
+      webdriverCommand = [],
+    }) => {
+      if (!selenoidConfig[browserName]) selenoidConfig[browserName] = { default: browserVersion, versions: {} };
+      if (!useDocker && webdriverCommand.length == 0)
+        throw new Error('Please specify "webdriverCommand" browser option with path to browser webdriver');
+      selenoidConfig[browserName].versions[browserVersion] = {
+        image: useDocker ? dockerImage : webdriverCommand,
+        port: '4444',
+        path: !useDocker || ['chrome', 'opera', 'webkit', 'MicrosoftEdge'].includes(browserName) ? '/' : '/wd/hub',
+      };
+    },
+  );
+
+  await mkdir(selenoidConfigDir, { recursive: true });
+  await writeFile(path.join(selenoidConfigDir, 'browsers.json'), JSON.stringify(selenoidConfig));
+
+  return selenoidConfigDir;
+}
+
+async function downloadSelenoidBinary(destination: string): Promise<void> {
+  const platformNameMapping: Partial<Record<NodeJS.Platform, string>> = {
+    darwin: 'selenoid_darwin_amd64',
+    linux: 'selenoid_linux_amd64',
+    win32: 'selenoid_windows_amd64.exe',
+  };
+  const octokit = new Octokit();
+  const response = await octokit.request('GET /repos/{owner}/{repo}/releases/latest', {
+    owner: 'aerokube',
+    repo: 'selenoid',
+  });
+  const { assets } = response.data;
+  const { browser_download_url: downloadUrl, size: binarySize } =
+    assets.find(({ name }) => platformNameMapping[process.platform] == name) ?? {};
+
+  if (existsSync(destination) && lstatSync(destination).size == binarySize) return;
+
+  if (!downloadUrl) {
+    throw new Error(
+      `Couldn't get download url for selenoid binary. Please download it manually from "https://github.com/aerokube/selenoid/releases/latest" and define "selenoidPath" option in the Creevey config`,
+    );
+  }
+
+  return downloadBinary(downloadUrl, destination);
+}
+
+export async function startSelenoidStandalone(config: Config, debug: boolean): Promise<void> {
+  config.gridUrl = 'http://localhost:4444/wd/hub';
+
+  if (cluster.isWorker) return;
+
+  const browsers = (Object.values(config.browsers) as BrowserConfig[]).filter((browser) => !browser.gridUrl);
+  const selenoidConfigDir = await createSelenoidConfig(browsers, { useDocker: false });
+  const binaryPath = path.join(selenoidConfigDir, process.platform == 'win32' ? 'selenoid.exe' : 'selenoid');
+  if (config.selenoidPath) {
+    await copyFile(path.resolve(config.selenoidPath), binaryPath);
+  } else {
+    await downloadSelenoidBinary(binaryPath);
+  }
+
+  // TODO Download browser webdrivers
+  try {
+    if (process.platform != 'win32') sh.chmod('+x', binaryPath);
+  } catch {
+    /* noop */
+  }
+
+  const selenoidProcess = sh.exec(`${binaryPath} -conf ./browsers.json -disable-docker`, {
+    async: true,
+    cwd: selenoidConfigDir,
+  });
+
+  if (debug) {
+    selenoidProcess.stdout?.pipe(process.stdout);
+    selenoidProcess.stderr?.pipe(process.stderr);
+  }
+
+  subscribeOn('shutdown', () => selenoidProcess.kill());
+}
+
+export async function startSelenoidContainer(config: Config, debug: boolean): Promise<string> {
+  const browsers = (Object.values(config.browsers) as BrowserConfig[]).filter((browser) => !browser.gridUrl);
+  const images: string[] = [];
+  let limit = 0;
+
+  browsers.forEach(
+    ({
+      browserName,
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      version = 'latest',
+      browserVersion = version,
+      limit: browserLimit = 1,
+      dockerImage = `selenoid/${browserName}:${browserVersion}`,
+    }) => {
+      limit += browserLimit;
+      images.push(dockerImage);
+    },
+  );
+
+  const selenoidImage = config.dockerImage;
+  const pullOptions = { auth: config.dockerAuth, platform: config.dockerImagePlatform };
+  if (config.pullImages) {
+    await pullImages([selenoidImage], pullOptions);
+    await pullImages(images, pullOptions);
+  }
+
+  // TODO Allow pass custom options
+  const selenoidOptions = {
+    ExposedPorts: { '4444/tcp': {} },
+    HostConfig: {
+      PortBindings: { '4444/tcp': [{ HostPort: '4444' }] },
+      Binds: [
+        '/var/run/docker.sock:/var/run/docker.sock',
+        `${await createSelenoidConfig(browsers, { useDocker: true })}:/etc/selenoid/:ro`,
+      ],
+    },
+  };
+
+  return runImage(selenoidImage, ['-limit', String(limit)], selenoidOptions, debug);
+}

package/src/server/stories.ts

@@ -0,0 +1,133 @@
+import path from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+import { createHash } from 'crypto';
+import _ from 'lodash';
+import type { Context } from 'mocha';
+import type {
+  TestData,
+  CreeveyStoryParams,
+  StoriesRaw,
+  SkipOptions,
+  ServerTest,
+  StoryInput,
+  CreeveyTestFunction,
+} from '../types.js';
+import { isDefined, isFunction } from '../types.js';
+import { shouldSkip } from './utils.js';
+
+function storyTestFabric(delay?: number, testFn?: CreeveyTestFunction) {
+  return async function storyTest(this: Context) {
+    if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
+    await (testFn
+      ? testFn.call(this)
+      : this.screenshots.length > 0
+        ? this.expect(
+            this.screenshots.reduce(
+              (screenshots, { imageName, screenshot }, index) => ({
+                ...screenshots,
+                [imageName ?? `screenshot_${index}`]: screenshot,
+              }),
+              {},
+            ),
+          ).to.matchImages()
+        : this.expect(await this.takeScreenshot()).to.matchImage());
+  };
+}
+
+function createCreeveyTest(
+  browser: string,
+  storyMeta: StoryInput,
+  skipOptions?: SkipOptions,
+  testName?: string,
+): TestData {
+  const { title, name, id: storyId } = storyMeta;
+  const path = [title, name, testName, browser].filter(isDefined);
+  const skip = skipOptions ? shouldSkip(browser, { title, name }, skipOptions, testName) : false;
+  const id = createHash('sha1').update(path.join('/')).digest('hex');
+  return { id, skip, browser, testName, storyPath: [...title.split('/').map((x) => x.trim()), name], storyId };
+}
+
+function convertStories(browserName: string, stories: StoriesRaw | StoryInput[]): Partial<Record<string, ServerTest>> {
+  const tests: Record<string, ServerTest> = {};
+
+  (Array.isArray(stories) ? stories : Object.values(stories)).forEach((storyMeta) => {
+    // TODO Skip docsOnly stories for now
+    if (storyMeta.parameters.docsOnly) return;
+
+    const { delay: delayParam, tests: storyTests, skip } = (storyMeta.parameters.creevey ?? {}) as CreeveyStoryParams;
+    const delay =
+      typeof delayParam == 'number' ? delayParam : delayParam?.for.includes(browserName) ? delayParam.ms : 0;
+
+    // typeof tests === "undefined" => rootSuite -> kindSuite -> storyTest -> [browsers.png]
+    // typeof tests === "function"  => rootSuite -> kindSuite -> storyTest -> browser -> [images.png]
+    // typeof tests === "object"    => rootSuite -> kindSuite -> storySuite -> test -> [browsers.png]
+    // typeof tests === "object"    => rootSuite -> kindSuite -> storySuite -> test -> browser -> [images.png]
+
+    if (!storyTests) {
+      const test = createCreeveyTest(browserName, storyMeta, skip);
+      tests[test.id] = { ...test, storyId: storyMeta.id, story: storyMeta, fn: storyTestFabric(delay) };
+      return;
+    }
+
+    Object.entries(storyTests).forEach(([testName, testFn]) => {
+      const test = createCreeveyTest(browserName, storyMeta, skip, testName);
+      tests[test.id] = { ...test, storyId: storyMeta.id, story: storyMeta, fn: storyTestFabric(delay, testFn) };
+    });
+  });
+
+  return tests;
+}
+
+export async function loadTestsFromStories(
+  browsers: string[],
+  provider: (storiesListener: (stories: Map<string, StoryInput[]>) => void) => Promise<StoriesRaw>,
+  update?: (testsDiff: Partial<Record<string, ServerTest>>) => void,
+): Promise<Partial<Record<string, ServerTest>>> {
+  const testIdsByFiles = new Map<string, string[]>();
+  const stories = await provider((storiesByFiles) => {
+    const testsDiff: Partial<Record<string, ServerTest>> = {};
+    const tests: Partial<Record<string, ServerTest>> = {};
+    browsers.forEach((browser) => {
+      Array.from(storiesByFiles.entries()).forEach(([filename, stories]) => {
+        Object.assign(tests, convertStories(browser, stories));
+        const changed = Object.keys(tests);
+        const removed = testIdsByFiles.get(filename)?.filter((testId) => !tests[testId]) ?? [];
+        if (changed.length == 0) testIdsByFiles.delete(filename);
+        else testIdsByFiles.set(filename, changed);
+
+        Object.assign(testsDiff, tests);
+        removed.forEach((testId) => (testsDiff[testId] = undefined));
+      });
+    });
+    update?.(testsDiff);
+  });
+
+  const tests = browsers.reduce(
+    (tests: Partial<Record<string, ServerTest>>, browser) => Object.assign(tests, convertStories(browser, stories)),
+    {},
+  );
+
+  Object.values(tests)
+    .filter(isDefined)
+    .forEach(
+      ({
+        id,
+        story: {
+          parameters: { fileName },
+        },
+      }) =>
+        // TODO Don't use filename as a key, due possible collisions if two require.context with same structure of modules are defined
+        testIdsByFiles.set(fileName as string, [...(testIdsByFiles.get(fileName as string) ?? []), id]),
+    );
+
+  return tests;
+}
+
+export function saveTestsJson(tests: Record<string, unknown>, dstPath: string = process.cwd()): void {
+  mkdirSync(dstPath, { recursive: true });
+  writeFileSync(
+    path.join(dstPath, 'tests.json'),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    JSON.stringify(tests, (_, value) => (isFunction(value) ? value.toString() : value), 2),
+  );
+}

package/src/server/storybook/providers/browser.ts

@@ -0,0 +1,58 @@
+import cluster from 'cluster';
+import type { CreeveyStory, StoriesProvider, StoriesRaw } from '../../../types.js';
+import { loadStoriesFromBrowser } from '../../selenium/index.js';
+import { emitStoriesMessage, sendStoriesMessage, subscribeOn, subscribeOnWorker } from '../../messages.js';
+import { isDefined } from '../../../types.js';
+import { logger } from '../../logger.js';
+import { deserializeRawStories } from '../../../shared/index.js';
+
+export const loadStories: StoriesProvider = async (_config, _options, storiesListener) => {
+  if (cluster.isPrimary) {
+    return new Promise<StoriesRaw>((resolve) => {
+      const worker = Object.values(cluster.workers ?? {})
+        .filter(isDefined)
+        .find((worker) => worker.isConnected());
+
+      if (worker) {
+        const unsubscribe = subscribeOnWorker(worker, 'stories', (message) => {
+          if (message.type == 'set') {
+            const { stories, oldTests } = message.payload;
+            if (oldTests.length > 0)
+              logger.warn(
+                `If you use browser stories provider of CSFv3 Storybook feature\n` +
+                  `Creevey will not load tests defined in story parameters from following stories:\n` +
+                  oldTests.join('\n'),
+              );
+            unsubscribe();
+            resolve(stories);
+          }
+        });
+        sendStoriesMessage(worker, { type: 'get' });
+      }
+      subscribeOn('stories', (message) => {
+        // TODO updates only one browser :(
+        if (message.type == 'update') storiesListener(new Map(message.payload));
+      });
+    });
+  } else {
+    subscribeOn('stories', (message) => {
+      if (message.type == 'get')
+        emitStoriesMessage({ type: 'set', payload: { stories, oldTests: storiesWithOldTests } });
+      if (message.type == 'update') storiesListener(new Map(message.payload));
+    });
+    const stories = deserializeRawStories(await loadStoriesFromBrowser());
+
+    const storiesWithOldTests: string[] = [];
+
+    Object.values(stories).forEach((story) => {
+      if ((story as CreeveyStory).parameters?.creevey?.tests) {
+        delete (story as CreeveyStory).parameters?.creevey?.tests;
+        storiesWithOldTests.push(`${story.title}/${story.name}`);
+      }
+    });
+
+    return stories;
+  }
+};
+
+loadStories.providerName = 'browser';

package/src/server/storybook/providers/hybrid.ts

@@ -0,0 +1,70 @@
+import chokidar from 'chokidar';
+
+import { loadStories as browserProvider } from './browser.js';
+import type { Config, StoryInput, CreeveyStoryParams, CreeveyStory, StoriesProvider } from '../../../types.js';
+import { logger } from '../../logger.js';
+import parse, { CreeveyParamsByStoryId } from '../../testsFiles/parser.js';
+import { readDirRecursive } from '../../utils.js';
+import { combineParameters } from '../../../shared/index.js';
+
+export const loadStories: StoriesProvider = async (
+  _config: Config,
+  _options,
+  storiesListener: (stories: Map<string, StoryInput[]>) => void,
+) => {
+  let creeveyParamsByStoryId: Partial<CreeveyParamsByStoryId> = {};
+
+  const mergeParamsFromTestsToStory = (story: CreeveyStory, creeveyParams: CreeveyStoryParams): void => {
+    if (story.parameters) {
+      story.parameters.creevey = combineParameters(story.parameters.creevey ?? {}, creeveyParams);
+    }
+  };
+
+  const stories = await browserProvider(_config, {}, (updatedStoriesByFiles) => {
+    Array.from(updatedStoriesByFiles.entries()).forEach(([, storiesArray]) => {
+      storiesArray.forEach((story) => {
+        const creeveyParams = creeveyParamsByStoryId[story.id];
+        if (creeveyParams) mergeParamsFromTestsToStory(story, creeveyParams);
+      });
+    });
+    storiesListener(updatedStoriesByFiles);
+  });
+
+  // TODO fix test files hot reloading
+  creeveyParamsByStoryId = await parseParams(_config /*, (data) => console.log(data) */);
+
+  Object.entries(stories).forEach(([storyId, story]) => {
+    const creeveyParams = creeveyParamsByStoryId[storyId];
+    if (creeveyParams) mergeParamsFromTestsToStory(story, creeveyParams);
+  });
+
+  return stories;
+};
+
+// TODO Check if it works with watch
+async function parseParams(
+  config: Config,
+  listener?: (data: CreeveyParamsByStoryId) => void,
+): Promise<CreeveyParamsByStoryId> {
+  if (!config.testsDir) {
+    return Promise.resolve({});
+  }
+
+  const testFiles = readDirRecursive(config.testsDir).filter((file) => config.testsRegex?.test(file));
+
+  if (listener) {
+    chokidar.watch(testFiles).on('change', (filePath) => {
+      logger.debug(`changed: ${filePath}`);
+
+      // doesn't work, always returns {} due modules caching
+      // see https://github.com/nodejs/modules/issues/307
+      void parse(testFiles).then((data) => {
+        listener(data);
+      });
+    });
+  }
+
+  return parse(testFiles);
+}
+
+loadStories.providerName = 'hybrid';

package/src/server/telemetry.ts

@@ -0,0 +1,212 @@
+import path from 'path';
+import https from 'https';
+import { exec } from 'shelljs';
+import { stringify } from 'qs';
+import { set } from 'lodash';
+import { v4 } from 'uuid';
+import { pathToFileURL } from 'url';
+import { createRequire } from 'module';
+import { Config, CreeveyStatus, isDefined, Options } from '../types';
+
+const konturGitHost = 'git.skbkontur.ru';
+
+const trackId = 232; // front_infra
+const origin = 'http://localhost/';
+const category = 'tests_run';
+const action = 'done';
+
+function buildPathname(label: string, info: Record<string, unknown>): string {
+  return `/track-event?${stringify({
+    id: trackId,
+    c: category,
+    a: action,
+    l: label,
+    cv: JSON.stringify(info),
+    ts: new Date().toISOString(),
+    url: origin,
+  })}`;
+}
+
+function sanitizeGridUrl(gridUrl: string): string {
+  const url = new URL(gridUrl);
+
+  url.username = url.username ? '********' : '';
+  url.password = url.password ? '********' : '';
+
+  return url.toString();
+}
+
+function tryGetRepoUrl(): [string | undefined, Error | null] {
+  try {
+    const gitRemoteOutput = exec('git remote -v', { silent: true });
+    const [, repoUrl] = /origin\s+(.*)\s+\(fetch\)/.exec(gitRemoteOutput.stdout) ?? [];
+    return [repoUrl, null];
+  } catch (error) {
+    return [undefined, error as Error];
+  }
+}
+
+function tryGetRootPath(): [string | undefined, Error | null] {
+  try {
+    const gitRevParseOutput = exec('git rev-parse --show-toplevel', { silent: true });
+    return [gitRevParseOutput.stdout.trim(), null];
+  } catch (error) {
+    return [undefined, error as Error];
+  }
+}
+
+function tryGetStorybookVersion(): [string | undefined, Error | null] {
+  try {
+    const storybookPackageOutput = exec(`node -e "console.log(JSON.stringify(require('storybook/package.json')))"`, {
+      silent: true,
+    });
+    const storybookPackage = JSON.parse(storybookPackageOutput.stdout) as { version: string };
+    return [storybookPackage.version, null];
+  } catch (error) {
+    return [undefined, error as Error];
+  }
+}
+
+function tryGetCreeveyVersion(): [string | undefined, Error | null] {
+  try {
+    const importMetaUrl = pathToFileURL(__filename).href;
+    const _require = createRequire(importMetaUrl);
+    const creeveyPackage = _require('creevey/package.json') as { version: string };
+    return [creeveyPackage.version, null];
+  } catch (error) {
+    return [undefined, error as Error];
+  }
+}
+
+function sendRequest(options: https.RequestOptions): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      if (res.statusCode) {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve();
+        } else if (res.statusCode >= 300 && res.statusCode < 400) {
+          reject(new Error(`Redirection error: ${res.statusCode}`));
+        } else if (res.statusCode >= 400 && res.statusCode < 500) {
+          reject(new Error(`Client error: ${res.statusCode}`));
+        } else if (res.statusCode >= 500 && res.statusCode < 600) {
+          reject(new Error(`Server error: ${res.statusCode}`));
+        } else {
+          reject(new Error(`Unexpected status code: ${res.statusCode}`));
+        }
+      } else {
+        reject(new Error('No status code received'));
+      }
+    });
+
+    req.on('error', reject);
+
+    req.end();
+  });
+}
+
+export async function sendScreenshotsCount(
+  config: Partial<Config>,
+  options: Options,
+  status?: CreeveyStatus,
+): Promise<void> {
+  const [repoUrl] = tryGetRepoUrl();
+
+  const isKonturRepo = repoUrl?.includes(konturGitHost);
+
+  if (!isKonturRepo || config.disableTelemetry) return;
+
+  const uuid = v4();
+
+  const [creeveyVersion, creeveyVersionError] = tryGetCreeveyVersion();
+  const [storybookVersion, storybookVersionError] = tryGetStorybookVersion();
+  const [gitRootPath] = tryGetRootPath();
+
+  const gridUrl = config.gridUrl ? sanitizeGridUrl(config.gridUrl) : undefined;
+
+  const configMeta = {
+    runId: uuid,
+    repoUrl: repoUrl ?? 'unknown',
+    creeveyVersion: creeveyVersion ?? 'unknown',
+    storybookVersion: storybookVersion ?? 'unknown',
+    options: options._,
+    gridUrl,
+    screenDir: config.screenDir ? path.relative(gitRootPath ?? process.cwd(), config.screenDir) : undefined,
+    useDocker: config.useDocker,
+    dockerImage: config.dockerImage,
+    maxRetries: config.maxRetries,
+    diffOptions: config.diffOptions,
+    storiesProvider: config.storiesProvider?.providerName ?? 'unknown',
+    errors: [creeveyVersionError, storybookVersionError].some(Boolean)
+      ? [
+          creeveyVersionError ? `Error while getting creevey version: ${creeveyVersionError.message}` : undefined,
+          storybookVersionError ? `Error while getting storybook version: ${storybookVersionError.message}` : undefined,
+        ].filter(Boolean)
+      : undefined,
+  };
+
+  const browsersMeta = {
+    runId: uuid,
+    browsers: Object.fromEntries(
+      Object.entries(config.browsers ?? {}).map(([name, browser]) => [
+        name,
+        typeof browser === 'object'
+          ? {
+              name: browser.name,
+              gridUrl: browser.gridUrl ? sanitizeGridUrl(browser.gridUrl) : undefined,
+              browserName: browser.browserName,
+              browserVersion: browser.browserVersion,
+              platformName: browser.platformName,
+              viewport: browser.viewport,
+              limit: browser.limit,
+              dockerImage: browser.dockerImage,
+              'se:teamname': browser['se:teamname'],
+            }
+          : browser,
+      ]),
+    ),
+  };
+
+  const tests: Record<string, unknown> = {};
+
+  Object.values(status?.tests ?? {})
+    .filter(isDefined)
+    .forEach((test) => {
+      set(tests, [...test.storyPath, test.testName, test.browser].filter(isDefined), test.id);
+    });
+
+  const testsMeta = { runId: uuid, tests };
+
+  const fullPathname = buildPathname('tests', testsMeta);
+  // NOTE: Keep request path shorter than 32k symbols
+  const chunksCount = Math.ceil(fullPathname.length / 32_000);
+  let chunks: string[] = [];
+  if (chunksCount > 1) {
+    const testsString = JSON.stringify(tests);
+    const chunkSize = Math.ceil(testsString.length / chunksCount);
+    chunks = Array.from({ length: chunksCount })
+      .map((_, chunkIndex) => testsString.slice(chunkIndex * chunkSize, (chunkIndex + 1) * chunkSize))
+      .map((testsPart, seq) => buildPathname('tests', { runId: uuid, seq, tests: testsPart }));
+  } else {
+    chunks = [fullPathname];
+  }
+
+  await Promise.all([
+    sendRequest({
+      host: 'metrika.kontur.ru',
+      path: buildPathname('config', configMeta),
+      protocol: 'https:',
+    }),
+    sendRequest({
+      host: 'metrika.kontur.ru',
+      path: buildPathname('browsers', browsersMeta),
+      protocol: 'https:',
+    }),
+    ...chunks.map((chunk) =>
+      sendRequest({
+        host: 'metrika.kontur.ru',
+        path: chunk,
+        protocol: 'https:',
+      }),
+    ),
+  ]);
+}

package/src/server/testsFiles/parser.ts

@@ -0,0 +1,62 @@
+import { pathToFileURL } from 'url';
+import { toId, storyNameFromExport } from '@storybook/csf';
+import { CreeveyStoryParams, CreeveyTestFunction } from '../../types.js';
+import { loadThroughTSX } from '../utils.js';
+
+export type CreeveyParamsByStoryId = Record<string, CreeveyStoryParams>;
+
+export default async function parse(files: string[]): Promise<CreeveyParamsByStoryId> {
+  result = {};
+
+  await loadThroughTSX(async (load) =>
+    Promise.all(
+      files.map(async (file) => {
+        const fileUrl = pathToFileURL(file).toString();
+        await load(fileUrl);
+      }),
+    ),
+  );
+
+  return result as CreeveyParamsByStoryId;
+}
+
+let result: Partial<CreeveyParamsByStoryId> = {};
+
+let kindTitle = '';
+let storyTitle = '';
+let storyParams: CreeveyStoryParams | null = null;
+
+const setStoryParameters = (params: CreeveyStoryParams): void => {
+  storyParams = params;
+};
+
+const getStoryId = (kindTitle: string, storyTitle: string): string => {
+  return toId(kindTitle, storyNameFromExport(storyTitle));
+};
+
+export const kind = (title: string, kindFn: () => void): void => {
+  kindTitle = title;
+  kindFn();
+  kindTitle = '';
+};
+
+export const story = (
+  title: string,
+  storyFn: (arg: { setStoryParameters: (params: CreeveyStoryParams) => void }) => void,
+): void => {
+  storyTitle = title;
+  storyParams = null;
+  storyFn({ setStoryParameters });
+  const storyId = getStoryId(kindTitle, storyTitle);
+  result[storyId] = Object.assign({}, storyParams, { tests: result[storyId]?.tests });
+  storyTitle = '';
+  storyParams = null;
+};
+
+export const test = (title: string, testFn: CreeveyTestFunction): void => {
+  const storyId = getStoryId(kindTitle, storyTitle);
+  if (!result[storyId]) {
+    result[storyId] = {};
+  }
+  result[storyId].tests = Object.assign({}, result[storyId].tests, { [title]: testFn });
+};