@dev-blinq/cucumber-js 1.0.6 → 1.0.8

package/lib/runtime/helpers.js

@@ -1,101 +1,101 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldCauseFailure = exports.retriesForPickle = exports.getAmbiguousStepException = void 0;
-const location_helpers_1 = require("../formatter/helpers/location_helpers");
-const cli_table3_1 = __importDefault(require("cli-table3"));
-const indent_string_1 = __importDefault(require("indent-string"));
-const pickle_filter_1 = require("../pickle_filter");
-const messages = __importStar(require("@cucumber/messages"));
-function getAmbiguousStepException(stepDefinitions) {
-    const table = new cli_table3_1.default({
-        chars: {
-            bottom: '',
-            'bottom-left': '',
-            'bottom-mid': '',
-            'bottom-right': '',
-            left: '',
-            'left-mid': '',
-            mid: '',
-            'mid-mid': '',
-            middle: ' - ',
-            right: '',
-            'right-mid': '',
-            top: '',
-            'top-left': '',
-            'top-mid': '',
-            'top-right': '',
-        },
-        style: {
-            border: [],
-            'padding-left': 0,
-            'padding-right': 0,
-        },
-    });
-    table.push(...stepDefinitions.map((stepDefinition) => {
-        const pattern = stepDefinition.pattern.toString();
-        return [pattern, (0, location_helpers_1.formatLocation)(stepDefinition)];
-    }));
-    return `${'Multiple step definitions match:' + '\n'}${(0, indent_string_1.default)(table.toString(), 2)}`;
-}
-exports.getAmbiguousStepException = getAmbiguousStepException;
-function retriesForPickle(pickle, options) {
-    if (!options.retry) {
-        return 0;
-    }
-    const retries = options.retry;
-    if (retries === 0) {
-        return 0;
-    }
-    const retryTagFilter = options.retryTagFilter;
-    if (!retryTagFilter) {
-        return retries;
-    }
-    const pickleTagFilter = new pickle_filter_1.PickleTagFilter(retryTagFilter);
-    if (pickleTagFilter.matchesAllTagExpressions(pickle)) {
-        return retries;
-    }
-    return 0;
-}
-exports.retriesForPickle = retriesForPickle;
-function shouldCauseFailure(status, options) {
-    if (options.dryRun) {
-        return false;
-    }
-    const failureStatuses = [
-        messages.TestStepResultStatus.AMBIGUOUS,
-        messages.TestStepResultStatus.FAILED,
-        messages.TestStepResultStatus.UNDEFINED,
-    ];
-    if (options.strict) {
-        failureStatuses.push(messages.TestStepResultStatus.PENDING);
-    }
-    return failureStatuses.includes(status);
-}
-exports.shouldCauseFailure = shouldCauseFailure;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldCauseFailure = exports.retriesForPickle = exports.getAmbiguousStepException = void 0;
+const location_helpers_1 = require("../formatter/helpers/location_helpers");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const pickle_filter_1 = require("../pickle_filter");
+const messages = __importStar(require("@cucumber/messages"));
+function getAmbiguousStepException(stepDefinitions) {
+    const table = new cli_table3_1.default({
+        chars: {
+            bottom: '',
+            'bottom-left': '',
+            'bottom-mid': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            middle: ' - ',
+            right: '',
+            'right-mid': '',
+            top: '',
+            'top-left': '',
+            'top-mid': '',
+            'top-right': '',
+        },
+        style: {
+            border: [],
+            'padding-left': 0,
+            'padding-right': 0,
+        },
+    });
+    table.push(...stepDefinitions.map((stepDefinition) => {
+        const pattern = stepDefinition.pattern.toString();
+        return [pattern, (0, location_helpers_1.formatLocation)(stepDefinition)];
+    }));
+    return `${'Multiple step definitions match:' + '\n'}${(0, indent_string_1.default)(table.toString(), 2)}`;
+}
+exports.getAmbiguousStepException = getAmbiguousStepException;
+function retriesForPickle(pickle, options) {
+    if (!options.retry) {
+        return 0;
+    }
+    const retries = options.retry;
+    if (retries === 0) {
+        return 0;
+    }
+    const retryTagFilter = options.retryTagFilter;
+    if (!retryTagFilter) {
+        return retries;
+    }
+    const pickleTagFilter = new pickle_filter_1.PickleTagFilter(retryTagFilter);
+    if (pickleTagFilter.matchesAllTagExpressions(pickle)) {
+        return retries;
+    }
+    return 0;
+}
+exports.retriesForPickle = retriesForPickle;
+function shouldCauseFailure(status, options) {
+    if (options.dryRun) {
+        return false;
+    }
+    const failureStatuses = [
+        messages.TestStepResultStatus.AMBIGUOUS,
+        messages.TestStepResultStatus.FAILED,
+        messages.TestStepResultStatus.UNDEFINED,
+    ];
+    if (options.strict) {
+        failureStatuses.push(messages.TestStepResultStatus.PENDING);
+    }
+    return failureStatuses.includes(status);
+}
+exports.shouldCauseFailure = shouldCauseFailure;
 //# sourceMappingURL=helpers.js.map

package/lib/runtime/index.d.ts

@@ -1,40 +1,40 @@
-/// <reference types="node" />
-import * as messages from '@cucumber/messages';
-import { IdGenerator } from '@cucumber/messages';
-import { EventEmitter } from 'events';
-import { EventDataCollector } from '../formatter/helpers';
-import { ISupportCodeLibrary } from '../support_code_library_builder/types';
-export interface IRuntime {
-    start: () => Promise<boolean>;
-}
-export interface INewRuntimeOptions {
-    eventBroadcaster: EventEmitter;
-    eventDataCollector: EventDataCollector;
-    newId: IdGenerator.NewId;
-    options: IRuntimeOptions;
-    pickleIds: string[];
-    supportCodeLibrary: ISupportCodeLibrary;
-}
-export interface IRuntimeOptions {
-    dryRun: boolean;
-    failFast: boolean;
-    filterStacktraces: boolean;
-    retry: number;
-    retryTagFilter: string;
-    strict: boolean;
-    worldParameters: any;
-}
-export default class Runtime implements IRuntime {
-    private readonly eventBroadcaster;
-    private readonly eventDataCollector;
-    private readonly stopwatch;
-    private readonly newId;
-    private readonly options;
-    private readonly pickleIds;
-    private readonly supportCodeLibrary;
-    private success;
-    private runTestRunHooks;
-    constructor({ eventBroadcaster, eventDataCollector, newId, options, pickleIds, supportCodeLibrary, }: INewRuntimeOptions);
-    runTestCase(pickleId: string, testCase: messages.TestCase): Promise<void>;
-    start(): Promise<boolean>;
-}
+/// <reference types="node" />
+import * as messages from '@cucumber/messages';
+import { IdGenerator } from '@cucumber/messages';
+import { EventEmitter } from 'events';
+import { EventDataCollector } from '../formatter/helpers';
+import { ISupportCodeLibrary } from '../support_code_library_builder/types';
+export interface IRuntime {
+    start: () => Promise<boolean>;
+}
+export interface INewRuntimeOptions {
+    eventBroadcaster: EventEmitter;
+    eventDataCollector: EventDataCollector;
+    newId: IdGenerator.NewId;
+    options: IRuntimeOptions;
+    pickleIds: string[];
+    supportCodeLibrary: ISupportCodeLibrary;
+}
+export interface IRuntimeOptions {
+    dryRun: boolean;
+    failFast: boolean;
+    filterStacktraces: boolean;
+    retry: number;
+    retryTagFilter: string;
+    strict: boolean;
+    worldParameters: any;
+}
+export default class Runtime implements IRuntime {
+    private readonly eventBroadcaster;
+    private readonly eventDataCollector;
+    private readonly stopwatch;
+    private readonly newId;
+    private readonly options;
+    private readonly pickleIds;
+    private readonly supportCodeLibrary;
+    private success;
+    private runTestRunHooks;
+    constructor({ eventBroadcaster, eventDataCollector, newId, options, pickleIds, supportCodeLibrary, }: INewRuntimeOptions);
+    runTestCase(pickleId: string, testCase: messages.TestCase): Promise<void>;
+    start(): Promise<boolean>;
+}

package/lib/runtime/index.js

@@ -1,76 +1,76 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const assemble_test_cases_1 = require("./assemble_test_cases");
-const helpers_1 = require("./helpers");
-const run_test_run_hooks_1 = require("./run_test_run_hooks");
-const stopwatch_1 = require("./stopwatch");
-const test_case_runner_1 = __importDefault(require("./test_case_runner"));
-class Runtime {
-    constructor({ eventBroadcaster, eventDataCollector, newId, options, pickleIds, supportCodeLibrary, }) {
-        this.eventBroadcaster = eventBroadcaster;
-        this.eventDataCollector = eventDataCollector;
-        this.stopwatch = (0, stopwatch_1.create)();
-        this.newId = newId;
-        this.options = options;
-        this.pickleIds = pickleIds;
-        this.supportCodeLibrary = supportCodeLibrary;
-        this.success = true;
-        this.runTestRunHooks = (0, run_test_run_hooks_1.makeRunTestRunHooks)(this.options.dryRun, this.supportCodeLibrary.defaultTimeout, (name, location) => `${name} hook errored, process exiting: ${location}`);
-    }
-    async runTestCase(pickleId, testCase) {
-        const pickle = this.eventDataCollector.getPickle(pickleId);
-        const retries = (0, helpers_1.retriesForPickle)(pickle, this.options);
-        const skip = this.options.dryRun || (this.options.failFast && !this.success);
-        const testCaseRunner = new test_case_runner_1.default({
-            eventBroadcaster: this.eventBroadcaster,
-            stopwatch: this.stopwatch,
-            gherkinDocument: this.eventDataCollector.getGherkinDocument(pickle.uri),
-            newId: this.newId,
-            pickle,
-            testCase,
-            retries,
-            skip,
-            filterStackTraces: this.options.filterStacktraces,
-            supportCodeLibrary: this.supportCodeLibrary,
-            worldParameters: this.options.worldParameters,
-        });
-        const status = await testCaseRunner.run();
-        if ((0, helpers_1.shouldCauseFailure)(status, this.options)) {
-            this.success = false;
-        }
-    }
-    async start() {
-        const testRunStarted = {
-            testRunStarted: {
-                timestamp: this.stopwatch.timestamp(),
-            },
-        };
-        this.eventBroadcaster.emit('envelope', testRunStarted);
-        this.stopwatch.start();
-        await this.runTestRunHooks(this.supportCodeLibrary.beforeTestRunHookDefinitions, 'a BeforeAll');
-        const assembledTestCases = await (0, assemble_test_cases_1.assembleTestCases)({
-            eventBroadcaster: this.eventBroadcaster,
-            newId: this.newId,
-            pickles: this.pickleIds.map((pickleId) => this.eventDataCollector.getPickle(pickleId)),
-            supportCodeLibrary: this.supportCodeLibrary,
-        });
-        for (const pickleId of this.pickleIds) {
-            await this.runTestCase(pickleId, assembledTestCases[pickleId]);
-        }
-        await this.runTestRunHooks(this.supportCodeLibrary.afterTestRunHookDefinitions.slice(0).reverse(), 'an AfterAll');
-        this.stopwatch.stop();
-        const testRunFinished = {
-            testRunFinished: {
-                timestamp: this.stopwatch.timestamp(),
-                success: this.success,
-            },
-        };
-        this.eventBroadcaster.emit('envelope', testRunFinished);
-        return this.success;
-    }
-}
-exports.default = Runtime;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assemble_test_cases_1 = require("./assemble_test_cases");
+const helpers_1 = require("./helpers");
+const run_test_run_hooks_1 = require("./run_test_run_hooks");
+const stopwatch_1 = require("./stopwatch");
+const test_case_runner_1 = __importDefault(require("./test_case_runner"));
+class Runtime {
+    constructor({ eventBroadcaster, eventDataCollector, newId, options, pickleIds, supportCodeLibrary, }) {
+        this.eventBroadcaster = eventBroadcaster;
+        this.eventDataCollector = eventDataCollector;
+        this.stopwatch = (0, stopwatch_1.create)();
+        this.newId = newId;
+        this.options = options;
+        this.pickleIds = pickleIds;
+        this.supportCodeLibrary = supportCodeLibrary;
+        this.success = true;
+        this.runTestRunHooks = (0, run_test_run_hooks_1.makeRunTestRunHooks)(this.options.dryRun, this.supportCodeLibrary.defaultTimeout, (name, location) => `${name} hook errored, process exiting: ${location}`);
+    }
+    async runTestCase(pickleId, testCase) {
+        const pickle = this.eventDataCollector.getPickle(pickleId);
+        const retries = (0, helpers_1.retriesForPickle)(pickle, this.options);
+        const skip = this.options.dryRun || (this.options.failFast && !this.success);
+        const testCaseRunner = new test_case_runner_1.default({
+            eventBroadcaster: this.eventBroadcaster,
+            stopwatch: this.stopwatch,
+            gherkinDocument: this.eventDataCollector.getGherkinDocument(pickle.uri),
+            newId: this.newId,
+            pickle,
+            testCase,
+            retries,
+            skip,
+            filterStackTraces: this.options.filterStacktraces,
+            supportCodeLibrary: this.supportCodeLibrary,
+            worldParameters: this.options.worldParameters,
+        });
+        const status = await testCaseRunner.run();
+        if ((0, helpers_1.shouldCauseFailure)(status, this.options)) {
+            this.success = false;
+        }
+    }
+    async start() {
+        const testRunStarted = {
+            testRunStarted: {
+                timestamp: this.stopwatch.timestamp(),
+            },
+        };
+        this.eventBroadcaster.emit('envelope', testRunStarted);
+        this.stopwatch.start();
+        await this.runTestRunHooks(this.supportCodeLibrary.beforeTestRunHookDefinitions, 'a BeforeAll');
+        const assembledTestCases = await (0, assemble_test_cases_1.assembleTestCases)({
+            eventBroadcaster: this.eventBroadcaster,
+            newId: this.newId,
+            pickles: this.pickleIds.map((pickleId) => this.eventDataCollector.getPickle(pickleId)),
+            supportCodeLibrary: this.supportCodeLibrary,
+        });
+        for (const pickleId of this.pickleIds) {
+            await this.runTestCase(pickleId, assembledTestCases[pickleId]);
+        }
+        await this.runTestRunHooks(this.supportCodeLibrary.afterTestRunHookDefinitions.slice(0).reverse(), 'an AfterAll');
+        this.stopwatch.stop();
+        const testRunFinished = {
+            testRunFinished: {
+                timestamp: this.stopwatch.timestamp(),
+                success: this.success,
+            },
+        };
+        this.eventBroadcaster.emit('envelope', testRunFinished);
+        return this.success;
+    }
+}
+exports.default = Runtime;
 //# sourceMappingURL=index.js.map

package/lib/runtime/parallel/command_types.d.ts

@@ -1,32 +1,32 @@
-import * as messages from '@cucumber/messages';
-import { IRuntimeOptions } from '../index';
-export interface IWorkerCommand {
-    initialize?: IWorkerCommandInitialize;
-    run?: IWorkerCommandRun;
-    finalize?: boolean;
-}
-export interface IWorkerCommandInitialize {
-    filterStacktraces: boolean;
-    requireModules: string[];
-    requirePaths: string[];
-    importPaths: string[];
-    supportCodeIds?: ICanonicalSupportCodeIds;
-    options: IRuntimeOptions;
-}
-export interface ICanonicalSupportCodeIds {
-    stepDefinitionIds: string[];
-    beforeTestCaseHookDefinitionIds: string[];
-    afterTestCaseHookDefinitionIds: string[];
-}
-export interface IWorkerCommandRun {
-    retries: number;
-    skip: boolean;
-    elapsed: messages.Duration;
-    pickle: messages.Pickle;
-    testCase: messages.TestCase;
-    gherkinDocument: messages.GherkinDocument;
-}
-export interface ICoordinatorReport {
-    jsonEnvelope?: string;
-    ready?: boolean;
-}
+import * as messages from '@cucumber/messages';
+import { IRuntimeOptions } from '../index';
+export interface IWorkerCommand {
+    initialize?: IWorkerCommandInitialize;
+    run?: IWorkerCommandRun;
+    finalize?: boolean;
+}
+export interface IWorkerCommandInitialize {
+    filterStacktraces: boolean;
+    requireModules: string[];
+    requirePaths: string[];
+    importPaths: string[];
+    supportCodeIds?: ICanonicalSupportCodeIds;
+    options: IRuntimeOptions;
+}
+export interface ICanonicalSupportCodeIds {
+    stepDefinitionIds: string[];
+    beforeTestCaseHookDefinitionIds: string[];
+    afterTestCaseHookDefinitionIds: string[];
+}
+export interface IWorkerCommandRun {
+    retries: number;
+    skip: boolean;
+    elapsed: messages.Duration;
+    pickle: messages.Pickle;
+    testCase: messages.TestCase;
+    gherkinDocument: messages.GherkinDocument;
+}
+export interface ICoordinatorReport {
+    jsonEnvelope?: string;
+    ready?: boolean;
+}

package/lib/runtime/parallel/command_types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=command_types.js.map

package/lib/runtime/parallel/coordinator.d.ts

@@ -1,72 +1,72 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-import * as messages from '@cucumber/messages';
-import { EventEmitter } from 'events';
-import { EventDataCollector } from '../../formatter/helpers';
-import { IRuntime, IRuntimeOptions } from '..';
-import { ISupportCodeLibrary } from '../../support_code_library_builder/types';
-import { ICoordinatorReport } from './command_types';
-import { IdGenerator } from '@cucumber/messages';
-import { ILogger } from '../../logger';
-export interface INewCoordinatorOptions {
-    cwd: string;
-    logger: ILogger;
-    eventBroadcaster: EventEmitter;
-    eventDataCollector: EventDataCollector;
-    options: IRuntimeOptions;
-    newId: IdGenerator.NewId;
-    pickleIds: string[];
-    supportCodeLibrary: ISupportCodeLibrary;
-    requireModules: string[];
-    requirePaths: string[];
-    importPaths: string[];
-    numberOfWorkers: number;
-}
-declare const enum WorkerState {
-    'idle' = 0,
-    'closed' = 1,
-    'running' = 2,
-    'new' = 3
-}
-interface IWorker {
-    state: WorkerState;
-    process: ChildProcess;
-    id: string;
-}
-interface IPicklePlacement {
-    index: number;
-    pickle: messages.Pickle;
-}
-export default class Coordinator implements IRuntime {
-    private readonly cwd;
-    private readonly eventBroadcaster;
-    private readonly eventDataCollector;
-    private readonly stopwatch;
-    private onFinish;
-    private readonly options;
-    private readonly newId;
-    private readonly pickleIds;
-    private assembledTestCases;
-    private inProgressPickles;
-    private workers;
-    private readonly supportCodeLibrary;
-    private readonly requireModules;
-    private readonly requirePaths;
-    private readonly importPaths;
-    private readonly numberOfWorkers;
-    private readonly logger;
-    private success;
-    private idleInterventions;
-    constructor({ cwd, logger, eventBroadcaster, eventDataCollector, pickleIds, options, newId, supportCodeLibrary, requireModules, requirePaths, importPaths, numberOfWorkers, }: INewCoordinatorOptions);
-    parseWorkerMessage(worker: IWorker, message: ICoordinatorReport): void;
-    awakenWorkers(triggeringWorker: IWorker): void;
-    startWorker(id: string, total: number): void;
-    onWorkerProcessClose(exitCode: number): void;
-    parseTestCaseResult(testCaseFinished: messages.TestCaseFinished): void;
-    start(): Promise<boolean>;
-    nextPicklePlacement(): IPicklePlacement;
-    placementAt(index: number): IPicklePlacement;
-    giveWork(worker: IWorker, force?: boolean): void;
-}
-export {};
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import * as messages from '@cucumber/messages';
+import { EventEmitter } from 'events';
+import { EventDataCollector } from '../../formatter/helpers';
+import { IRuntime, IRuntimeOptions } from '..';
+import { ISupportCodeLibrary } from '../../support_code_library_builder/types';
+import { ICoordinatorReport } from './command_types';
+import { IdGenerator } from '@cucumber/messages';
+import { ILogger } from '../../logger';
+export interface INewCoordinatorOptions {
+    cwd: string;
+    logger: ILogger;
+    eventBroadcaster: EventEmitter;
+    eventDataCollector: EventDataCollector;
+    options: IRuntimeOptions;
+    newId: IdGenerator.NewId;
+    pickleIds: string[];
+    supportCodeLibrary: ISupportCodeLibrary;
+    requireModules: string[];
+    requirePaths: string[];
+    importPaths: string[];
+    numberOfWorkers: number;
+}
+declare const enum WorkerState {
+    'idle' = 0,
+    'closed' = 1,
+    'running' = 2,
+    'new' = 3
+}
+interface IWorker {
+    state: WorkerState;
+    process: ChildProcess;
+    id: string;
+}
+interface IPicklePlacement {
+    index: number;
+    pickle: messages.Pickle;
+}
+export default class Coordinator implements IRuntime {
+    private readonly cwd;
+    private readonly eventBroadcaster;
+    private readonly eventDataCollector;
+    private readonly stopwatch;
+    private onFinish;
+    private readonly options;
+    private readonly newId;
+    private readonly pickleIds;
+    private assembledTestCases;
+    private inProgressPickles;
+    private workers;
+    private readonly supportCodeLibrary;
+    private readonly requireModules;
+    private readonly requirePaths;
+    private readonly importPaths;
+    private readonly numberOfWorkers;
+    private readonly logger;
+    private success;
+    private idleInterventions;
+    constructor({ cwd, logger, eventBroadcaster, eventDataCollector, pickleIds, options, newId, supportCodeLibrary, requireModules, requirePaths, importPaths, numberOfWorkers, }: INewCoordinatorOptions);
+    parseWorkerMessage(worker: IWorker, message: ICoordinatorReport): void;
+    awakenWorkers(triggeringWorker: IWorker): void;
+    startWorker(id: string, total: number): void;
+    onWorkerProcessClose(exitCode: number): void;
+    parseTestCaseResult(testCaseFinished: messages.TestCaseFinished): void;
+    start(): Promise<boolean>;
+    nextPicklePlacement(): IPicklePlacement;
+    placementAt(index: number): IPicklePlacement;
+    giveWork(worker: IWorker, force?: boolean): void;
+}
+export {};