creevey 0.7.39 → 0.9.0-beta.0

package/lib/esm/server/storybook/{nodejs-provider.js → providers/nodejs.js}

@@ -2,15 +2,15 @@
 import path from 'path';
 import { isWorker, isMaster } from 'cluster';
 import chokidar from 'chokidar';
-import { noop } from '../../types';
-import { getCreeveyCache } from '../utils';
-import { subscribeOn } from '../messages';
-import { importStorybookClientLogger, importStorybookConfig, importStorybookCoreCommon, importStorybookCoreEvents, isStorybookVersionLessThan } from './helpers';
-import { logger } from '../logger';
-import { flatStories } from '../stories';
+import { noop } from '../../../types';
+import { getCreeveyCache } from '../../utils';
+import { subscribeOn } from '../../messages';
+import { importStorybookClientLogger, importStorybookConfig, importStorybookCoreCommon, importStorybookCoreEvents, isStorybookVersionGreaterThan, isStorybookVersionLessThan } from '../helpers';
+import { logger } from '../../logger';
+import { denormalizeStoryParameters } from '../../../shared';
 
 async function initStorybookEnvironment() {
-  // @ts-ignore
+  // @ts-expect-error There is no @types/global-jsdom package
   (await import('global-jsdom')).default(undefined, {
     url: 'http://localhost'
   }); // NOTE Cutoff `jsdom` part from userAgent, because storybook check enviroment and create events channel if runs in browser
@@ -28,7 +28,7 @@ async function initStorybookEnvironment() {
   if (isWorker) logger.warn = noop; // NOTE: disable logger for 5.x storybook
 
   logger.debug = noop;
-  return import('./entry');
+  return import('../entry');
 }
 
 function watchStories(channel, watcher, initialFiles) {
@@ -39,7 +39,7 @@ function watchStories(channel, watcher, initialFiles) {
   watcher.on('change', filePath => storiesByFiles.set(path.isAbsolute(filePath) ? filePath : `./${filePath.replace(/\\/g, '/')}`, []));
   watcher.on('unlink', filePath => storiesByFiles.set(path.isAbsolute(filePath) ? filePath : `./${filePath.replace(/\\/g, '/')}`, []));
   return data => {
-    const stories = isStorybookVersionLessThan(6) ? data.stories : flatStories(data);
+    const stories = isStorybookVersionLessThan(6) || isStorybookVersionGreaterThan(6, 3) ? data.stories : denormalizeStoryParameters(data);
     const files = new Set(Object.values(stories).map(story => story.parameters.fileName));
     const addedFiles = Array.from(files).filter(filePath => !watchingFiles.has(filePath));
     const removedFiles = Array.from(watchingFiles).filter(filePath => !files.has(filePath));
@@ -84,13 +84,14 @@ async function loadStoriesDirectly(config, {
   debug
 }) {
   const {
-    toRequireContext
+    toRequireContext,
+    normalizeStoriesEntry
   } = await importStorybookCoreCommon();
   const {
     addParameters,
     configure
-  } = await import('./entry');
-  const requireContext = await (await import('../loaders/babel/register')).default(config, debug);
+  } = await import('../entry');
+  const requireContext = await (await import('../../loaders/babel/register')).default(config, debug);
 
   const preview = (() => {
     try {
@@ -103,12 +104,16 @@ async function loadStoriesDirectly(config, {
   const {
     stories
   } = await importStorybookConfig();
-  const contexts = stories.map(input => {
+  const contexts = stories.map(entry => {
+    const normalizedEntry = isStorybookVersionLessThan(6, 4) ? entry : normalizeStoriesEntry(entry, {
+      configDir: config.storybookDir,
+      workingDir: process.cwd()
+    });
     const {
       path: storiesPath,
       recursive,
       match
-    } = toRequireContext(input);
+    } = toRequireContext(normalizedEntry);
     watcher === null || watcher === void 0 ? void 0 : watcher.add(path.resolve(config.storybookDir, storiesPath));
     return () => requireContext(storiesPath, recursive, new RegExp(match));
   });
@@ -162,7 +167,8 @@ async function loadStoriesDirectly(config, {
     void startStorybook();
   });
   void startStorybook();
-}
+} // TODO Do we need to support multiple storybooks here?
+
 
 export async function loadStories(config, {
   watch,
@@ -175,16 +181,16 @@ export async function loadStories(config, {
   } = storybookApi;
   channel.removeAllListeners(Events.CURRENT_STORY_WAS_SET);
   channel.on('storiesUpdated', storiesListener);
-  let watcher = null;
+  let watcher;
   if (watch) watcher = chokidar.watch([], {
     ignoreInitial: true
   });
   const loadPromise = new Promise(resolve => {
     channel.once(Events.SET_STORIES, data => {
-      const stories = isStorybookVersionLessThan(6) ? data.stories : flatStories(data);
+      const stories = isStorybookVersionLessThan(6) || isStorybookVersionGreaterThan(6, 3) ? data.stories : denormalizeStoryParameters(data);
       const files = new Set(Object.values(stories).map(story => story.parameters.fileName));
       if (watcher) channel.on(Events.SET_STORIES, watchStories(channel, watcher, files));
-      resolve(data);
+      resolve(stories);
     });
   });
   if (config.useWebpackToExtractTests) loadStoriesFromBundle(watch);else void loadStoriesDirectly(config, {
@@ -192,4 +198,20 @@ export async function loadStories(config, {
     debug
   });
   return loadPromise;
+}
+export async function extractStoriesData(config, {
+  watch,
+  debug
+}) {
+  const storybookApi = await initStorybookEnvironment();
+  const Events = await importStorybookCoreEvents();
+  const {
+    channel
+  } = storybookApi;
+  channel.removeAllListeners(Events.CURRENT_STORY_WAS_SET);
+  const loadPromise = new Promise(resolve => channel.once(Events.SET_STORIES, resolve));
+  if (config.useWebpackToExtractTests) loadStoriesFromBundle(watch);else void loadStoriesDirectly(config, {
+    debug
+  });
+  return loadPromise;
 }

package/lib/esm/server/utils.js

@@ -1,4 +1,4 @@
-import { createWriteStream, existsSync, readFileSync, unlink } from 'fs';
+import { createWriteStream, existsSync, readFileSync, readdirSync, unlink } from 'fs';
 import cluster from 'cluster';
 import { isDefined, noop, isFunction } from '../types';
 import { emitShutdownMessage, sendShutdownMessage } from './messages';
@@ -9,6 +9,7 @@ export const isShuttingDown = {
 };
 export const LOCALHOST_REGEXP = /(localhost|127\.0\.0\.1)/i;
 export const extensions = ['.js', '.jsx', '.ts', '.tsx'];
+export const skipOptionKeys = ['in', 'kinds', 'stories', 'tests', 'reason'];
 
 function matchBy(pattern, value) {
   return typeof pattern == 'string' && pattern == value || Array.isArray(pattern) && pattern.includes(value) || pattern instanceof RegExp && pattern.test(value) || !isDefined(pattern);
@@ -20,9 +21,30 @@ export function shouldSkip(browser, meta, skipOptions, test) {
   }
 
   if (Array.isArray(skipOptions)) {
-    return skipOptions.map(skipOption => shouldSkip(browser, meta, skipOption, test)).find(Boolean) || false;
+    for (const skip of skipOptions) {
+      const reason = shouldSkip(browser, meta, skip, test);
+      if (reason) return reason;
+    }
+
+    return false;
+  }
+
+  let hasSkipOptionKeys = false;
+
+  for (const skipKey in skipOptions) {
+    if (skipOptionKeys.includes(skipKey)) {
+      hasSkipOptionKeys = true;
+      continue;
+    }
+
+    const reason = shouldSkip(browser, meta, {
+      reason: skipKey,
+      ...skipOptions[skipKey]
+    }, test);
+    if (reason) return reason;
   }
 
+  if (!hasSkipOptionKeys) return false;
   const {
     in: browsers,
     kinds,
@@ -116,4 +138,9 @@ export function removeProps(obj, propPath) {
     if (typeof prop == 'string') delete obj[prop];
     if (isFunction(prop)) Object.keys(obj).filter(prop).forEach(key => delete obj[key]);
   }
+}
+export function readDirRecursive(dirPath) {
+  return [].concat(...readdirSync(dirPath, {
+    withFileTypes: true
+  }).map(dirent => dirent.isDirectory() ? readDirRecursive(`${dirPath}/${dirent.name}`) : [`${dirPath}/${dirent.name}`]));
 }

package/lib/esm/server/worker/helpers.js

@@ -47,14 +47,10 @@ function removeTestOrSuite(testOrSuite) {
 
 export async function addTestsFromStories(rootSuite, config, {
   browser,
-  watch,
-  debug
+  ...options
 }) {
   const mochaTestsById = new Map();
-  const tests = await loadTestsFromStories([browser], listener => config.storiesProvider(config, {
-    watch,
-    debug
-  }, listener), testsDiff => Object.entries(testsDiff).forEach(([id, newTest]) => {
+  const tests = await loadTestsFromStories([browser], listener => config.storiesProvider(config, options, listener), testsDiff => Object.entries(testsDiff).forEach(([id, newTest]) => {
     const oldTest = mochaTestsById.get(id);
     mochaTestsById.delete(id);
     if (oldTest) removeTestOrSuite(oldTest);

package/lib/esm/server/worker/worker.js

@@ -8,7 +8,7 @@ import { Key, until } from 'selenium-webdriver';
 import { isImageError } from '../../types';
 import { subscribeOn, emitTestMessage, emitWorkerMessage } from '../messages';
 import chaiImage from './chai-image';
-import { getBrowser, switchStory } from '../selenium';
+import { closeBrowser, getBrowser, switchStory } from '../selenium';
 import { CreeveyReporter, TeamcityReporter } from './reporter';
 import { addTestsFromStories } from './helpers';
 import { logger } from '../logger';
@@ -49,6 +49,7 @@ export default async function worker(config, options) {
   let retries = 0;
   let images = {};
   let error = undefined;
+  const screenshots = [];
   const testScope = [];
 
   function runHandler(failures) {
@@ -173,13 +174,23 @@ export default async function worker(config, options) {
 
   mocha.cleanReferencesAfterRun(false);
   chai.use(chaiImage(getExpected, config.diffOptions));
+  if ((await getBrowser(config, options.browser)) == null) return;
   await addTestsFromStories(mocha.suite, config, {
     browser: options.browser,
     watch: options.ui,
-    debug: options.debug
+    debug: options.debug,
+    port: options.port
   });
-  const browserConfig = config.browsers[options.browser];
-  const browser = await getBrowser(config, browserConfig);
+
+  try {
+    var _await$getBrowser;
+
+    await ((_await$getBrowser = await getBrowser(config, options.browser)) === null || _await$getBrowser === void 0 ? void 0 : _await$getBrowser.getCurrentUrl());
+  } catch (_) {
+    await closeBrowser();
+  }
+
+  const browser = await getBrowser(config, options.browser);
   const sessionId = (_await$browser$getSes = await (browser === null || browser === void 0 ? void 0 : browser.getSession())) === null || _await$browser$getSes === void 0 ? void 0 : _await$browser$getSes.getId();
   if (browser == null) return;
   const interval = setInterval(() => void browser.getCurrentUrl().then(url => {
@@ -194,6 +205,7 @@ export default async function worker(config, options) {
     this.expect = chai.expect;
     this.browserName = options.browser;
     this.testScope = testScope;
+    this.screenshots = screenshots;
   });
   mocha.suite.beforeEach(switchStory);
   subscribeOn('test', message => {

package/lib/esm/shared.js

@@ -0,0 +1,76 @@
+import { mapValues, mergeWith, cloneDeepWith } from 'lodash';
+// NOTE: Copy-paste from storybook/api
+export const combineParameters = (...parameterSets) => // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+mergeWith({}, ...parameterSets, (_, srcValue) => {
+  // Treat arrays as scalars:
+  if (Array.isArray(srcValue)) return srcValue;
+  return undefined;
+}); // NOTE: Copy-paste from storybook/api
+
+export const denormalizeStoryParameters = ({
+  globalParameters,
+  kindParameters,
+  stories
+}) => {
+  return mapValues(stories, storyData => {
+    var _globalParameters$cre, _kindParameters$story, _kindParameters$story2;
+
+    storyData.parameters.creevey = combineParameters((_globalParameters$cre = globalParameters.creevey) !== null && _globalParameters$cre !== void 0 ? _globalParameters$cre : {}, (_kindParameters$story = (_kindParameters$story2 = kindParameters[storyData.kind]) === null || _kindParameters$story2 === void 0 ? void 0 : _kindParameters$story2.creevey) !== null && _kindParameters$story !== void 0 ? _kindParameters$story : {}, storyData.parameters.creevey);
+    return storyData;
+  });
+};
+export const isSerializedRegExp = exp => {
+  return typeof exp === 'object' && exp !== null && Reflect.get(exp, '__regexp') === true;
+};
+export const serializeRegExp = exp => {
+  const {
+    source,
+    flags
+  } = exp;
+  return {
+    __regexp: true,
+    source,
+    flags
+  };
+};
+export const deserializeRegExp = ({
+  source,
+  flags
+}) => {
+  return new RegExp(source, flags);
+};
+export const serializeRawStories = stories => {
+  return mapValues(stories, storyData => {
+    const creevey = storyData.parameters.creevey;
+
+    if ((creevey === null || creevey === void 0 ? void 0 : creevey.skip) !== undefined) {
+      creevey.skip = cloneDeepWith(creevey.skip, value => {
+        if (value instanceof RegExp) {
+          return serializeRegExp(value);
+        }
+
+        return undefined;
+      });
+    }
+
+    return storyData;
+  });
+};
+export const deserializeRawStories = stories => {
+  return mapValues(stories, deserializeStory);
+};
+export const deserializeStory = story => {
+  const creevey = story.parameters.creevey;
+
+  if ((creevey === null || creevey === void 0 ? void 0 : creevey.skip) !== undefined) {
+    creevey.skip = cloneDeepWith(creevey.skip, value => {
+      if (isSerializedRegExp(value)) {
+        return deserializeRegExp(value);
+      }
+
+      return undefined;
+    });
+  }
+
+  return story;
+};

package/lib/esm/types.js

@@ -29,6 +29,9 @@ export function isProcessMessage(message) {
 export function isWorkerMessage(message) {
   return isProcessMessage(message) && message.scope == 'worker';
 }
+export function isStoriesMessage(message) {
+  return isProcessMessage(message) && message.scope == 'stories';
+}
 export function isTestMessage(message) {
   return isProcessMessage(message) && message.scope == 'test';
 }

package/lib/types/client/addon/preset.d.ts

@@ -3,12 +3,14 @@ import { Configuration } from 'webpack';
 export declare function config(entry?: string[]): string[];
 export declare function managerEntries(entry?: string[]): string[];
 declare global {
+    const __CREEVEY_SERVER_HOST__: string;
     const __CREEVEY_SERVER_PORT__: number;
     const __CREEVEY_CLIENT_PORT__: number | null;
 }
 export interface CreeveyAddonOptions {
     creeveyConfigPath?: string;
     creeveyPreExtract?: string;
+    creeveyHost?: string;
     creeveyPort?: number;
     clientPort?: number;
     configType: string;

package/lib/types/client/addon/readyForCapture.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Window {
+        __CREEVEY_SET_READY_FOR_CAPTURE__?: () => void;
+    }
+}
+export declare function readyForCapture(): void;

package/lib/types/client/addon/utils.d.ts

@@ -1,6 +1,2 @@
-import { Parameters } from '@storybook/api';
-import { SetStoriesPayload } from '@storybook/api/dist/ts3.9/lib/stories';
-import { StoriesRaw, TestStatus } from '../../types';
+import { TestStatus } from '../../types';
 export declare function getEmojiByTestStatus(status: TestStatus | undefined, skip?: string | boolean): string;
-export declare const combineParameters: (...parameterSets: Parameters[]) => Parameters;
-export declare const denormalizeStoryParameters: ({ globalParameters, kindParameters, stories, }: SetStoriesPayload) => StoriesRaw;

package/lib/types/client/addon/withCreevey.d.ts

@@ -1,13 +1,24 @@
+import type { PreviewWeb } from '@storybook/preview-web';
+import type { AnyFramework } from '@storybook/csf';
+import type { StoryStore } from '@storybook/client-api';
 import { MakeDecoratorResult, Channel } from '@storybook/addons';
-import { StorybookGlobals } from '../../types';
+import { CaptureOptions, StoriesRaw, StorybookGlobals } from '../../types';
 declare global {
     interface Window {
-        __CREEVEY_SELECT_STORY__: (storyId: string, kind: string, name: string, shouldWaitForReady: boolean, callback: (error?: string) => void) => void;
+        __CREEVEY_SERVER_HOST__: string;
+        __CREEVEY_SERVER_PORT__: number;
+        __CREEVEY_WORKER_ID__: number;
+        __CREEVEY_GET_STORIES__: () => Promise<StoriesRaw | void>;
+        __CREEVEY_SELECT_STORY__: (storyId: string, kind: string, name: string, shouldWaitForReady: boolean, callback: (response: [error?: string | null, isCaptureCalled?: boolean]) => void) => void;
         __CREEVEY_UPDATE_GLOBALS__: (globals: StorybookGlobals) => void;
         __CREEVEY_INSERT_IGNORE_STYLES__: (ignoreElements: string[]) => HTMLStyleElement;
         __CREEVEY_REMOVE_IGNORE_STYLES__: (ignoreStyles: HTMLStyleElement) => void;
+        __CREEVEY_HAS_PLAY_COMPLETED_YET__: (callback: (isPlayCompleted: boolean) => void) => void;
         __CREEVEY_SET_READY_FOR_CAPTURE__?: () => void;
         __STORYBOOK_ADDONS_CHANNEL__: Channel;
+        __STORYBOOK_STORY_STORE__: StoryStore<AnyFramework>;
+        __STORYBOOK_PREVIEW__: PreviewWeb<AnyFramework>;
     }
 }
 export declare function withCreevey(): MakeDecoratorResult;
+export declare function capture(options?: CaptureOptions): Promise<void>;

package/lib/types/client/web/CreeveyView/SideBar/SuiteLink.d.ts

@@ -4,7 +4,7 @@ import { Theme } from '@storybook/theming';
 export interface SuiteLinkProps {
     title: string;
     suite: CreeveySuite;
-    'data-tid'?: string;
+    'data-testid'?: string;
 }
 export declare const Container: React.SFC<import("emotion-theming/types/helper").AddOptionalTo<Pick<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & Pick<{
     theme: Theme;
@@ -30,4 +30,4 @@ export declare const Button: React.SFC<import("emotion-theming/types/helper").Ad
 export declare const SuiteContainer: import("@emotion/styled-base").StyledComponent<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
     padding: number;
 }, Theme>;
-export declare function SuiteLink({ title, suite, 'data-tid': dataTid }: SuiteLinkProps): JSX.Element;
+export declare function SuiteLink({ title, suite, 'data-testid': dataTid }: SuiteLinkProps): JSX.Element;

package/lib/types/index.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="../../types/chai" />
 export * from './types';
-export * from './client/addon/withCreevey';
+// export * from './client/addon/withCreevey';
+export * from './server/parser';

package/lib/types/server/config.d.ts

@@ -1,4 +1,4 @@
 import { Config, Options } from '../types';
 export declare const defaultBrowser = "chrome";
-export declare const defaultConfig: Omit<Config, 'gridUrl' | 'storiesProvider'>;
+export declare const defaultConfig: Omit<Config, 'gridUrl' | 'storiesProvider' | 'testDir'>;
 export declare function readConfig(options: Options): Promise<Config>;

package/lib/types/server/master/master.d.ts

@@ -3,4 +3,5 @@ import Runner from './runner';
 export default function master(config: Config, options: {
     watch: boolean;
     debug: boolean;
+    port: number;
 }): Promise<Runner>;

package/lib/types/server/master/pool.d.ts

@@ -26,5 +26,6 @@ export default class Pool extends EventEmitter {
     private exitHandler;
     private gracefullyKill;
     private shouldRetry;
+    private handleTestResult;
     private subscribe;
 }

package/lib/types/server/master/server.d.ts

@@ -1,2 +1,2 @@
 import { CreeveyApi } from './api';
-export default function server(reportDir: string, port: number): (api: CreeveyApi) => void;
+export default function server(reportDir: string, port: number, ui: boolean): (api: CreeveyApi) => void;

package/lib/types/server/messages.d.ts

@@ -1,18 +1,28 @@
 /// <reference types="webpack-env" />
 /// <reference types="node" />
 import cluster from 'cluster';
-import { WorkerMessage, TestMessage, WebpackMessage, DockerMessage, WorkerHandler, TestHandler, WebpackHandler, DockerHandler, ShutdownHandler } from '../types';
+import { WorkerMessage, StoriesMessage, TestMessage, WebpackMessage, DockerMessage, WorkerHandler, StoriesHandler, TestHandler, WebpackHandler, DockerHandler, ShutdownHandler } from '../types';
 export declare function emitWorkerMessage(message: WorkerMessage): boolean;
+export declare function emitStoriesMessage(message: StoriesMessage): boolean;
 export declare function emitTestMessage(message: TestMessage): boolean;
 export declare function emitWebpackMessage(message: WebpackMessage): boolean;
 export declare function emitDockerMessage(message: DockerMessage): boolean;
 export declare function emitShutdownMessage(): boolean;
+export declare function sendStoriesMessage(target: NodeJS.Process | cluster.Worker, message: StoriesMessage): void;
 export declare function sendTestMessage(target: NodeJS.Process | cluster.Worker, message: TestMessage): void;
 export declare function sendDockerMessage(target: NodeJS.Process | cluster.Worker, message: DockerMessage): void;
 export declare function sendShutdownMessage(target: NodeJS.Process | cluster.Worker): void;
 export declare function subscribeOn(scope: 'worker', handler: WorkerHandler): () => void;
+export declare function subscribeOn(scope: 'stories', handler: StoriesHandler): () => void;
 export declare function subscribeOn(scope: 'test', handler: TestHandler): () => void;
 export declare function subscribeOn(scope: 'webpack', handler: WebpackHandler): () => void;
 export declare function subscribeOn(scope: 'docker', handler: DockerHandler): () => void;
 export declare function subscribeOn(scope: 'shutdown', handler: ShutdownHandler): () => void;
-export declare function subscribeOn(scope: 'worker' | 'test' | 'webpack' | 'docker' | 'shutdown', handler: WorkerHandler | TestHandler | WebpackHandler | DockerHandler | ShutdownHandler): () => void;
+export declare function subscribeOn(scope: 'worker' | 'stories' | 'test' | 'webpack' | 'docker' | 'shutdown', handler: WorkerHandler | StoriesHandler | TestHandler | WebpackHandler | DockerHandler | ShutdownHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'worker', handler: WorkerHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'stories', handler: StoriesHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'test', handler: TestHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'webpack', handler: WebpackHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'docker', handler: DockerHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'shutdown', handler: ShutdownHandler): () => void;
+export declare function subscribeOnWorker(worker: cluster.Worker, scope: 'worker' | 'stories' | 'test' | 'webpack' | 'docker' | 'shutdown', handler: WorkerHandler | StoriesHandler | TestHandler | WebpackHandler | DockerHandler | ShutdownHandler): () => void;

package/lib/types/server/parser.d.ts

@@ -0,0 +1,12 @@
+import { CreeveyStoryParams, CreeveyTestFunction } from '../types';
+export declare type CreeveyParamsByStoryId = {
+    [storyId: string]: CreeveyStoryParams;
+};
+export default function parse(files: string[]): Promise<CreeveyParamsByStoryId>;
+declare const setStoryParameters: (params: CreeveyStoryParams) => void;
+export declare const kind: (title: string, kindFn: () => void) => void;
+export declare const story: (title: string, storyFn: (arg: {
+    setStoryParameters: (params: CreeveyStoryParams) => void;
+}) => void) => void;
+export declare const test: (title: string, testFn: CreeveyTestFunction) => void;
+export {};

package/lib/types/server/selenium/browser.d.ts

@@ -1,6 +1,6 @@
 import { Context } from 'mocha';
 import { WebDriver } from 'selenium-webdriver';
-import { BrowserConfig, Config, StorybookGlobals } from '../../types';
+import { Config, StorybookGlobals, StoriesRaw } from '../../types';
 declare global {
     interface Window {
         __CREEVEY_RESTORE_SCROLL__?: () => void;
@@ -9,6 +9,9 @@ declare global {
         __CREEVEY_REMOVE_IGNORE_STYLES__: (ignoreStyles: HTMLStyleElement) => void;
     }
 }
+export declare function takeScreenshot(browser: WebDriver, captureElement?: string | null, ignoreElements?: string | string[] | null): Promise<string>;
 export declare function updateStorybookGlobals(browser: WebDriver, globals: StorybookGlobals): Promise<void>;
-export declare function getBrowser(config: Config, browserConfig: BrowserConfig): Promise<WebDriver | null>;
+export declare function loadStoriesFromBrowser(port: number): Promise<StoriesRaw>;
+export declare function getBrowser(config: Config, name: string): Promise<WebDriver | null>;
+export declare function closeBrowser(): Promise<void>;
 export declare function switchStory(this: Context): Promise<void>;

package/lib/types/server/stories.d.ts

@@ -1,6 +1,5 @@
 import type { StoriesRaw, ServerTest, StoryInput, SetStoriesData } from '../types';
-export declare function flatStories({ globalParameters, kindParameters, stories }: SetStoriesData): StoriesRaw;
-export declare function loadTestsFromStories(browsers: string[], provider: (storiesListener: (stories: Map<string, StoryInput[]>) => void) => Promise<SetStoriesData>, update?: (testsDiff: Partial<{
+export declare function loadTestsFromStories(browsers: string[], provider: (storiesListener: (stories: Map<string, StoryInput[]>) => void) => Promise<StoriesRaw>, update?: (testsDiff: Partial<{
     [id: string]: ServerTest;
 }>) => void): Promise<Partial<{
     [id: string]: ServerTest;

package/lib/types/server/storybook/entry.d.ts

@@ -1,14 +1,18 @@
 /// <reference types="node" />
 /// <reference types="webpack-env" />
 import type { StoryApi } from '@storybook/addons';
-export declare const channel: import("@storybook/channels").Channel;
-export declare const clientApi: import("@storybook/core").ClientApi;
-export declare const forceReRender: () => void;
+import type { Channel } from '@storybook/channels';
+declare const start: typeof import("@storybook/core").start;
+export declare const channel: Channel;
+declare type ClientApi = ReturnType<typeof start>['clientApi'];
+export declare const clientApi: ClientApi;
+export declare const forceReRender: (() => never) | (() => void);
 export declare const storiesOf: (kind: string, m: NodeModule) => StoryApi;
 export declare const configure: (...args: unknown[]) => unknown;
-export declare const addDecorator: (decorator: import("@storybook/addons").DecoratorFunction<unknown>) => void;
-export declare const addParameters: (parameters: import("@storybook/addons").Parameters) => void;
-export declare const clearDecorators: () => void;
-export declare const setAddon: (addon: any) => void;
-export declare const getStorybook: () => import("@storybook/client-api").GetStorybookKind[];
-export declare const raw: () => import("@storybook/client-api").PublishedStoreItem[];
+export declare const addDecorator: ClientApi['addDecorator'];
+export declare const addParameters: ClientApi['addParameters'];
+export declare const clearDecorators: ClientApi['clearDecorators'];
+export declare const setAddon: (() => never) | ((addon: any) => void);
+export declare const getStorybook: ClientApi['getStorybook'];
+export declare const raw: ClientApi['raw'];
+export {};

package/lib/types/server/storybook/helpers.d.ts

@@ -14,6 +14,7 @@ export declare function hasDocsAddon(): boolean;
 export declare function hasSvelteCSFAddon(): boolean;
 export declare function getStorybookVersion(): string;
 export declare function isStorybookVersionLessThan(major: number, minor?: number): boolean;
+export declare function isStorybookVersionGreaterThan(major: number, minor?: number): boolean;
 export declare function isStorybookVersion(major: number, minor?: number): boolean;
 export declare function getStorybookFramework(): string;
 export declare const storybookConfigRef: {

package/lib/types/server/storybook/providers/browser.d.ts

@@ -0,0 +1,4 @@
+import type { Config, StoriesRaw, StoryInput } from '../../../types';
+export declare function loadStories(_config: Config, { port }: {
+    port: number;
+}, storiesListener: (stories: Map<string, StoryInput[]>) => void): Promise<StoriesRaw>;

package/lib/types/server/storybook/providers/hybrid.d.ts

@@ -0,0 +1,4 @@
+import type { Config, StoriesRaw, StoryInput } from '../../../types';
+export declare function loadStories(_config: Config, { port }: {
+    port: number;
+}, storiesListener: (stories: Map<string, StoryInput[]>) => void): Promise<StoriesRaw>;

package/lib/types/server/storybook/providers/nodejs.d.ts

@@ -0,0 +1,9 @@
+import type { StoryInput, SetStoriesData, Config, StoriesRaw } from '../../../types';
+export declare function loadStories(config: Config, { watch, debug }: {
+    watch: boolean;
+    debug: boolean;
+}, storiesListener: (stories: Map<string, StoryInput[]>) => void): Promise<StoriesRaw>;
+export declare function extractStoriesData(config: Config, { watch, debug }: {
+    watch: boolean;
+    debug: boolean;
+}): Promise<SetStoriesData>;

package/lib/types/server/utils.d.ts

@@ -4,6 +4,7 @@ export declare const isShuttingDown: {
 };
 export declare const LOCALHOST_REGEXP: RegExp;
 export declare const extensions: string[];
+export declare const skipOptionKeys: string[];
 export declare function shouldSkip(browser: string, meta: {
     kind: string;
     story: string;
@@ -16,3 +17,4 @@ export declare function testsToImages(tests: (TestData | undefined)[]): Set<stri
 export declare const isInsideDocker: boolean;
 export declare const downloadBinary: (downloadUrl: string, destination: string) => Promise<void>;
 export declare function removeProps(obj: Record<string, unknown>, propPath: (string | ((key: string) => boolean))[]): void;
+export declare function readDirRecursive(dirPath: string): string[];

package/lib/types/server/worker/helpers.d.ts

@@ -1,7 +1,8 @@
 import { Suite } from 'mocha';
 import { Config } from '../../types';
-export declare function addTestsFromStories(rootSuite: Suite, config: Config, { browser, watch, debug }: {
+export declare function addTestsFromStories(rootSuite: Suite, config: Config, { browser, ...options }: {
     browser: string;
     watch: boolean;
     debug: boolean;
+    port: number;
 }): Promise<void>;

package/lib/types/shared.d.ts

@@ -0,0 +1,16 @@
+import { Parameters } from '@storybook/api';
+import { SetStoriesData, StoriesRaw, StoryInput } from './types';
+export declare const combineParameters: (...parameterSets: Parameters[]) => Parameters;
+export declare const denormalizeStoryParameters: ({ globalParameters, kindParameters, stories, }: SetStoriesData) => StoriesRaw;
+interface SerializedRegExp {
+    __regexp: true;
+    source: string;
+    flags: string;
+}
+export declare const isSerializedRegExp: (exp: unknown) => exp is SerializedRegExp;
+export declare const serializeRegExp: (exp: RegExp) => SerializedRegExp;
+export declare const deserializeRegExp: ({ source, flags }: SerializedRegExp) => RegExp;
+export declare const serializeRawStories: (stories: StoriesRaw) => StoriesRaw;
+export declare const deserializeRawStories: (stories: StoriesRaw) => StoriesRaw;
+export declare const deserializeStory: (story: StoryInput) => StoryInput;
+export {};