@flemist/test-variants 3.0.2 → 5.0.0

package/build/common/test-variants/-test/invariants/ErrorBehaviorInvariant.d.ts

@@ -0,0 +1,32 @@
+import { TestVariantsResult, TestVariantsRunOptions } from '../../..';
+import { TestError } from '../helpers/TestError';
+import { StressTestArgs, TestArgs } from '../types';
+/**
+ * Validates error handling behavior
+ *
+ * ## Applicability
+ * Active for all test executions. Validates error propagation based on
+ * findBestError and dontThrowIfError options.
+ *
+ * ## Validated Rules
+ * - When error expected and dontThrowIfError=true: no error thrown, bestError populated
+ * - When error expected and dontThrowIfError=false: error thrown, matches lastThrownError
+ * - When no error expected: no error thrown, bestError is null
+ */
+export declare class ErrorBehaviorInvariant {
+    private readonly _options;
+    private readonly _runOptions;
+    private readonly _variantsCount;
+    private readonly _errorVariantIndex;
+    private readonly _retriesToError;
+    constructor(options: StressTestArgs, runOptions: TestVariantsRunOptions<TestArgs>, variantsCount: number, errorVariantIndex: number | null, retriesToError: number);
+    /**
+     * Validates error behavior after test execution
+     *
+     * @param callCount - Number of test function calls
+     * @param caughtError - The error that was thrown (or null)
+     * @param lastThrownError - The last TestError that occurred (or null)
+     * @param result - The test result (may be null if error thrown)
+     */
+    validate(callCount: number, caughtError: unknown, lastThrownError: TestError | null, result: TestVariantsResult<TestArgs> | null): void;
+}

package/build/common/test-variants/-test/invariants/FindBestErrorInvariant.d.ts

@@ -0,0 +1,37 @@
+import { TestVariantsResult, TestVariantsRunOptions } from '../../..';
+import { TestError } from '../helpers/TestError';
+import { StressTestArgs, TestArgs } from '../types';
+/**
+ * Validates findBestError behavior
+ *
+ * ## Applicability
+ * Active when findBestError is enabled
+ *
+ * ## Validated Rules
+ * - dontThrowIfError=true + error: caughtError is null, bestError populated
+ * - dontThrowIfError=false + error: caughtError is thrown at end
+ * - includeErrorVariant=false: error variant never retested after first error
+ * - Error at variant 0: testing terminates (no better error possible)
+ * - Continues testing variants 0..(errorVariant-1) after error until limits
+ *
+ * ## Skipped Cases
+ * - parallel > 1 without sequentialOnError (race conditions)
+ * - attemptsPerVariant > 1 (can't distinguish retry from retest)
+ * - dynamic templates (variant indices don't have same meaning)
+ */
+export declare class FindBestErrorInvariant {
+    private readonly _options;
+    private readonly _runOptions;
+    private readonly _errorVariantIndex;
+    private readonly _errorVariantArgs;
+    private _errorOccurred;
+    private _errorVariantRetestedAfterError;
+    private _callsAfterError;
+    constructor(options: StressTestArgs, runOptions: TestVariantsRunOptions<TestArgs>, errorVariantIndex: number | null, errorVariantArgs: TestArgs | null);
+    /** Call inside test func before potential error */
+    onCall(args: TestArgs): void;
+    /** Call when error occurs */
+    onError(): void;
+    /** Run after test variants completion */
+    validateFinal(caughtError: unknown, lastThrownError: TestError | null, result: TestVariantsResult<TestArgs> | null): void;
+}

package/build/common/test-variants/-test/invariants/IterationsInvariant.d.ts

@@ -0,0 +1,21 @@
+import { TestVariantsResult } from '../../..';
+import { StressTestArgs, TestArgs } from '../types';
+/**
+ * Validates iteration count in test result
+ *
+ * ## Applicability
+ * Test completion when result is returned
+ *
+ * ## Invariants
+ * - iterations ≥ 0
+ * - iterations equals sum of iterations from all completed test calls
+ * - Calculation based on completedCount
+ * - Mixed mode: call 1 is sync, call 2 is async, call 3 is sync, etc
+ */
+export declare class IterationsInvariant {
+    private readonly _options;
+    constructor(options: StressTestArgs);
+    /** Run after test variants completion */
+    validateFinal(completedCount: number, result: TestVariantsResult<TestArgs> | null): void;
+    private _calculateExpectedIterations;
+}

package/build/common/test-variants/-test/invariants/LimitTimeInvariant.d.ts

@@ -0,0 +1,26 @@
+import { ModeChangeEvent, TestVariantsRunOptions } from '../../..';
+import { TimeControllerMock } from '@flemist/time-controller';
+import { TestArgs } from '../types';
+/**
+ * Validates time limit constraints
+ *
+ * ## Applicability
+ * - Every mode change event
+ * - Test completion
+ *
+ * ## Invariants
+ * - Each mode's runtime ≤ its limitTime (if set)
+ * - Total runtime ≤ global limitTime (if set)
+ */
+export declare class LimitTimeInvariant {
+    private readonly _runOptions;
+    private readonly _timeController;
+    private readonly _startTime;
+    private _modeStartTime;
+    private _lastModeIndex;
+    constructor(runOptions: TestVariantsRunOptions<TestArgs>, timeController: TimeControllerMock);
+    /** Use in onModeChange callback */
+    onModeChange(event: ModeChangeEvent): void;
+    /** Run after test variants completion */
+    validateFinal(): void;
+}

package/build/common/test-variants/-test/invariants/LogInvariant.d.ts

@@ -0,0 +1,126 @@
+import { TestVariantsLogOptions } from '../../..';
+import { TestVariantsLogType } from '../../types';
+import { RequiredNonNullable } from '@flemist/simple-utils';
+/**
+ * Validates log callback behavior
+ *
+ * ## Applicability
+ * Active when log options are provided to runOptions.
+ * Validates every log callback invocation during test execution.
+ *
+ * ## Invariants
+ *
+ * ### Per-log validation (onLog)
+ * - Each log type is called exclusively when its corresponding option is enabled
+ * - No logs occur after 'completed'
+ * - 'start' log called exactly once, before any other logs
+ * - 'completed' log called exactly once, at the end
+ * - 'progress' logs occur exclusively after at least one test call (tests > 0)
+ * - 'modeChange' and 'debug' logs can occur before test calls
+ *
+ * ### Content validation (values only, not format)
+ * - 'start': no value checks
+ * - 'completed': tests value (callCount)
+ * - 'modeChange': modeIndex value, mode name value (forward/backward/random)
+ * - 'progress': tests value (callCount)
+ * - 'error': tests value (callCount - 1, tests completed before error)
+ * - 'debug': no value checks
+ *
+ * ### Log examples
+ *
+ * start:
+ * ```
+ * [test-variants] start, memory: 139MB
+ * ```
+ *
+ * progress:
+ * ```
+ * [test-variants] tests: 615 (5.0s), async: 12, memory: 148MB (+8.8MB)
+ * ```
+ *
+ * modeChange:
+ * ```
+ * [test-variants] mode[0]: forward
+ * [test-variants] mode[1]: backward, limitTests=10
+ * [test-variants] mode[2]: random, limitTime=10.9m
+ * ```
+ *
+ * completed:
+ * ```
+ * [test-variants] end, tests: 815 (7.0s), async: 123, memory: 138MB (-1.0MB)
+ * ```
+ *
+ * error:
+ * ```
+ * [test-variants] error variant: {arg1: value1}
+ * Error: test error message
+ * tests: 5
+ * ```
+ *
+ * debug:
+ * ```
+ * [test-variants] debug iteration: 0
+ * ```
+ *
+ * ## Note on modeChange validation
+ *
+ * Library calls onModeChange callback BEFORE emitting modeChange log (throttled).
+ * LogInvariant stores expected mode info in onModeChange, then validates
+ * when modeChange log is received.
+ */
+export declare class LogInvariant {
+    private _logStartCount;
+    private _logCompletedCount;
+    private _logProgressCount;
+    private _logModeChangeCount;
+    private _logErrorCount;
+    private _logDebugCount;
+    private _anyLogAfterCompleted;
+    /** Stores expected mode info for validation when modeChange log is received */
+    private _pendingModeInfo;
+    private readonly _logOptions;
+    private readonly _parallelLimit;
+    constructor(logOptions: RequiredNonNullable<TestVariantsLogOptions>, parallelLimit: number);
+    /**
+     * Call when mode changes to store expected mode info
+     *
+     * Library calls onModeChange callback BEFORE logFunc('modeChange', ...),
+     * so we store expected info here for validation when log is received
+     */
+    onModeChange(modeIndex: number, modeName: string): void;
+    /** Call for each log func invocation */
+    onLog(type: TestVariantsLogType, message: string, tests: number): void;
+    private _validateStartLog;
+    private _validateCompletedLog;
+    private _onModeChangeLog;
+    /**
+     * Validates progress log content
+     *
+     * With parallel execution, tests value in log (library's state.tests) may
+     * differ from callCount due to timing differences.
+     */
+    private _validateProgressLog;
+    /**
+     * Validates error log content
+     *
+     * Note: tests parameter is callCount (calls started), but error log shows
+     * tests completed before error, which is callCount - 1.
+     * With parallel execution, tests value in log may differ from callCount - 1
+     * because more tests may have started between dispatch and error.
+     */
+    private _validateErrorLog;
+    private _validateDebugLog;
+    /**
+     * Run after test variants completion
+     *
+     * @param onErrorCount - number of onError callback calls
+     * @param completedSkipped - true if completed log was skipped (error thrown without findBestError)
+     */
+    validateFinal(onErrorCount: number, completedSkipped: boolean): void;
+    get logStartCount(): number;
+    get logCompletedCount(): number;
+    get logProgressCount(): number;
+    get logModeChangeCount(): number;
+    get logErrorCount(): number;
+    get logDebugCount(): number;
+}

package/build/common/test-variants/-test/invariants/OnErrorInvariant.d.ts

@@ -0,0 +1,38 @@
+import { TestVariantsRunOptions } from '../../..';
+import { TestArgs } from '../types';
+import { TestError } from '../helpers/TestError';
+/**
+ * Validates onError callback behavior
+ *
+ * ## Applicability
+ * Active when errors occur during test execution.
+ * Validates onError callback is called correctly.
+ *
+ * ## Validated Rules
+ * - error parameter is instanceof TestError
+ * - error parameter matches lastThrownError (sequential execution)
+ * - args parameter matches errorVariantArgs (ignoring seed)
+ * - tests parameter is non-negative integer not exceeding callCount
+ * - tests parameter does not decrease in findBestError mode
+ * - Without findBestError: onError called at most once
+ * - With findBestError: onError can be called multiple times
+ * - If error occurred, onError was called at least once
+ * - If no error occurred, onError was never called
+ *
+ * ## Skipped Cases
+ * - parallel > 1 without sequentialOnError (race conditions)
+ */
+export declare class OnErrorInvariant {
+    private _onErrorCount;
+    private _lastOnErrorTests;
+    private readonly _runOptions;
+    private readonly _errorVariantArgs;
+    constructor(runOptions: TestVariantsRunOptions<TestArgs>, errorVariantArgs: TestArgs | null);
+    onError(event: {
+        error: unknown;
+        args: TestArgs;
+        tests: number;
+    }, callCount: number, lastThrownError: TestError | null): void;
+    get onErrorCount(): number;
+    validateFinal(lastThrownError: TestError | null): void;
+}

package/build/common/test-variants/-test/invariants/OnModeChangeInvariant.d.ts

@@ -0,0 +1,32 @@
+import { ModeChangeEvent, TestVariantsRunOptions } from '../../..';
+import { NumberRange } from '@flemist/simple-utils';
+import { TestArgs } from '../types';
+/**
+ * Validates onModeChange callback behavior
+ *
+ * ## Applicability
+ * Every mode change event
+ *
+ * ## Invariants
+ * - onModeChange count within estimated range [min, max] (skipped when time limits present)
+ * - First modeChange: modeIndex=0, tests=0
+ * - modeIndex cycles in order: 0→1→...→N-1→0→...
+ * - modeIndex within range [0, modesCount)
+ * - mode reference equals iterationModes[modeIndex]
+ * - tests ≥ 0
+ * - tests increases monotonically
+ */
+export declare class OnModeChangeInvariant {
+    private _modeChangeCount;
+    private _lastTests;
+    private _lastModeIndex;
+    private readonly _runOptions;
+    private readonly _modeChangesRange;
+    private readonly _hasTimeLimits;
+    constructor(runOptions: TestVariantsRunOptions<TestArgs>, modeChangesRange: NumberRange);
+    private _detectTimeLimits;
+    /** Use in onModeChange callback */
+    onModeChange(event: ModeChangeEvent): void;
+    /** Run after test variants completion */
+    validateFinal(): void;
+}

package/build/common/test-variants/-test/invariants/ParallelInvariant.d.ts

@@ -0,0 +1,25 @@
+import { TestVariantsRunOptions } from '../../..';
+import { StressTestArgs, TestArgs } from '../types';
+import { CallController } from '../helpers/CallController';
+/**
+ * Validates parallel execution behavior
+ *
+ * ## Applicability
+ * Active when parallel execution is configured. Validates concurrency.
+ *
+ * ## Validated Rules
+ * - Concurrent calls never exceed parallelLimit
+ * - All calls complete (currentConcurrent === 0) after test execution
+ * - Sync-only tests (isAsync=false) have maxConcurrent === 1
+ * - With parallelLimit > 1 and enough calls, maxConcurrent === parallelLimit
+ */
+export declare class ParallelInvariant {
+    private readonly _options;
+    private readonly _runOptions;
+    private readonly _callController;
+    constructor(options: StressTestArgs, runOptions: TestVariantsRunOptions<TestArgs>, callController: CallController);
+    /** Call inside test func after call starts */
+    onCall(): void;
+    /** Run after test variants completion */
+    validateFinal(): void;
+}

package/build/common/test-variants/-test/log.d.ts

@@ -0,0 +1,3 @@
+export declare let logEnabled: boolean;
+export declare function isLogEnabled(): boolean;
+export declare function runWithLogs<T>(func: () => T): T;

package/build/common/test-variants/-test/types.d.ts

@@ -0,0 +1,34 @@
+export type ObjectValue = {
+    value: number;
+};
+export type TemplateValue = number | ObjectValue;
+export type TemplateArray = readonly TemplateValue[];
+export type TestArgs = Record<string, TemplateValue>;
+export type TemplateFunc = (args: TestArgs) => TemplateArray;
+export type Template = Record<string, TemplateArray | TemplateFunc>;
+export type StressTestArgs = {
+    argType: 'static' | 'dynamic' | null;
+    argValueType: 'primitive' | 'object' | null;
+    argsCountMax: number;
+    argValuesCountMax: number;
+    argValueMax: number;
+    errorVariantIndex: 'none' | 0 | 1 | 'last' | 'after-last' | null;
+    retriesToErrorMax: number;
+    findBestError: boolean | null;
+    limitArgOnError: false | true | 'func' | null;
+    includeErrorVariant: boolean | null;
+    dontThrowIfError: boolean | null;
+    withSeed: boolean | null;
+    attemptsPerVariantMax: number;
+    completionCounts: number;
+    modeType: 'forward' | 'backward' | 'random' | null;
+    modeCyclesMax: number;
+    modeAttemptsMax: number;
+    modesCountMax: number;
+    withEquals: boolean | null;
+    parallel: number | boolean | null;
+    async: boolean | null;
+    withDelay: boolean | null;
+    withLog: boolean | null;
+    seed: number;
+};

package/build/common/test-variants/-test/variants.d.ts

@@ -0,0 +1,3 @@
+import { StressTestArgs } from './types';
+import { TestVariantsSetArgs } from '../types';
+export declare const testVariants: TestVariantsSetArgs<StressTestArgs>;

package/build/common/test-variants/createTestRun.d.ts

@@ -0,0 +1,3 @@
+import { Obj } from '@flemist/simple-utils';
+import { TestVariantsCreateTestRunOptions, TestVariantsTest, TestVariantsTestRun } from './run/types';
+export declare function createTestRun<Args extends Obj>(test: TestVariantsTest<Args>, options: TestVariantsCreateTestRunOptions<Args>): TestVariantsTestRun<Args>;

package/build/common/test-variants/createTestVariants.d.ts

@@ -0,0 +1,4 @@
+import { Obj } from '@flemist/simple-utils';
+import { TestVariantsTest } from './run/types';
+import { TestVariantsSetArgs } from './types';
+export declare function createTestVariants<Args extends Obj>(test: TestVariantsTest<Args>): TestVariantsSetArgs<Args>;

package/build/common/test-variants/iterator/createVariantsIterator.d.ts

@@ -0,0 +1,4 @@
+import { Obj } from '@flemist/simple-utils';
+import { VariantsIterator, VariantsIteratorOptions } from './types';
+/** Creates test variants iterator with limiting capabilities */
+export declare function createVariantsIterator<Args extends Obj>(options: VariantsIteratorOptions<Args>): VariantsIterator<Args>;

package/build/common/test-variants/iterator/helpers/findValueIndex.d.ts

@@ -0,0 +1,2 @@
+/** Find index of value in array; returns -1 if not found */
+export declare function findValueIndex<T>(values: readonly T[], value: T, equals?: null | ((a: T, b: T) => boolean)): number;

package/build/common/test-variants/iterator/helpers/mode.d.ts

@@ -0,0 +1,3 @@
+import { BackwardModeConfig, ForwardModeConfig, ModeConfig } from '../../types';
+/** Check if mode is sequential (forward or backward) */
+export declare function isModeSequential(modeConfig: ModeConfig): modeConfig is ForwardModeConfig | BackwardModeConfig;

package/build/common/test-variants/iterator/helpers/template.d.ts

@@ -0,0 +1,7 @@
+import { Obj } from '@flemist/simple-utils';
+import { Equals } from '../../types';
+import { TestVariantsTemplates, TestVariantsTemplatesWithExtra } from '../types';
+/** Extend templates with all extra values */
+export declare function extendTemplatesWithExtraArgs<Args extends Obj>(templates: TestVariantsTemplatesWithExtra<Args, any>, args: Args, equals?: null | Equals): void;
+/** Check if all args except `seed` exist in template */
+export declare function isArgsKeysInTemplate<Args extends Obj>(template: TestVariantsTemplates<Args>, args: Args): boolean;

package/build/common/test-variants/iterator/types.d.ts

@@ -0,0 +1,102 @@
+import { Mutable, Obj } from '@flemist/simple-utils';
+import { ITimeController } from '@flemist/time-controller';
+import { ArgsWithSeed, Equals, GetSeedParams, LimitArgOnError, ModeConfig, OnModeChangeCallback } from '../types';
+/** Limit information with args and optional error */
+export type VariantsIteratorLimit<Args extends Obj> = {
+    args: ArgsWithSeed<Args>;
+    error?: unknown;
+    /** Number of tests run when this limit was applied */
+    tests: number;
+};
+/** Options for addLimit method */
+export type AddLimitOptions<Args extends Obj> = {
+    args?: null | ArgsWithSeed<Args>;
+    error?: unknown;
+    /** Number of tests run when this limit is applied */
+    tests?: null | number;
+};
+/** Options for creating test variants iterator */
+export type VariantsIteratorOptions<Args extends Obj> = {
+    argsTemplates: TestVariantsTemplates<Args>;
+    /** Custom equality for comparing arg values */
+    equals?: null | Equals;
+    /** Limit per-arg indexes on error; boolean enables/disables, function for custom per-arg logic */
+    limitArgOnError?: null | boolean | LimitArgOnError;
+    /** When true, error variant is included in iteration (for debugging); default false excludes it */
+    includeErrorVariant?: null | boolean;
+    /** Generates seed for reproducible randomized testing; seed is added to args */
+    getSeed?: null | ((params: GetSeedParams) => any);
+    /** Iteration modes (variant traversal methods); each mode runs until its limits are reached */
+    iterationModes?: null | readonly ModeConfig[];
+    /** Time controller for testable time-dependent operations; null uses timeControllerDefault */
+    timeController?: null | ITimeController;
+    /** Callback invoked when iteration mode changes */
+    onModeChange?: null | OnModeChangeCallback;
+    /** Global completion count limit; default 1 */
+    limitCompletionCount?: null | number;
+    /** Global tests limit */
+    limitTests?: null | number;
+    /** Global time limit in ms */
+    limitTime?: null | number;
+};
+/** State for each iteration mode */
+export type ModeState<Args extends Obj> = {
+    /** Position and arg state, independent per mode */
+    navigationState: VariantNavigationState<Args>;
+    /** Full passes through all variants; resets to 0 when completedCount increments */
+    cycleCount: number;
+    /** Times mode reached its cycles config limit; only grows */
+    completedCount: number;
+    /** Tests since last switch to this mode; for "did nothing" check */
+    testsInLastTurn: number;
+    /** Count of attempts to get next variant in current mode */
+    tryNextVariantAttempts: number;
+    /** Set on first iteration after switching to mode; for per-mode limitTime check */
+    startTime: number | null;
+};
+/** Test variants iterator with limiting capabilities */
+export type VariantsIterator<Args extends Obj> = {
+    /** Last applied limit's args and error; null if no args-based limit applied */
+    readonly limit: VariantsIteratorLimit<Args> | null;
+    /** Current mode index in modes array */
+    readonly modeIndex: number;
+    readonly modeConfigs: readonly ModeConfig[];
+    readonly modeStates: ModeState<Args>[];
+    /** Total tests count; for external logging, events, etc */
+    readonly tests: number;
+    /** Add or tighten limit */
+    addLimit(options?: null | AddLimitOptions<Args>): void;
+    /** Get next variant or null when done */
+    next(): ArgsWithSeed<Args> | null;
+};
+export type TestVariantsTemplateValues<Value> = readonly Value[];
+export type TestVariantsTemplateFunc<Args extends Obj, Value> = (args: Args) => readonly Value[];
+export type TestVariantsTemplate<Args extends Obj, Value> = TestVariantsTemplateValues<Value> | TestVariantsTemplateFunc<Args, Value>;
+export type ArgName<Args extends Obj> = Extract<keyof Args, string>;
+export type TestVariantsTemplates<Args extends Obj> = {
+    [key in ArgName<Args>]: TestVariantsTemplate<Args, Args[key]>;
+};
+export type TestVariantsTemplatesExtra<Args extends Obj> = {
+    [key in ArgName<Args>]?: Mutable<TestVariantsTemplateValues<Args[key]>>;
+};
+export type TestVariantsTemplatesWithExtra<Args extends Obj, Extra extends Obj> = {
+    templates: TestVariantsTemplates<Args>;
+    extra: TestVariantsTemplatesExtra<Extra>;
+};
+/** State required for variant navigation */
+export type VariantNavigationState<Args extends Obj> = {
+    args: Args;
+    argsNames: ArgName<Args>[];
+    indexes: number[];
+    argValues: (readonly any[])[];
+    argLimits: (number | null)[];
+    attempts: number;
+    templates: TestVariantsTemplatesWithExtra<Args, any>;
+    limitArgOnError: null | boolean | LimitArgOnError;
+    equals: null | Equals;
+    includeErrorVariant: boolean;
+};
+/** Extended templates type that allows additional args beyond the base Args type */
+export type TestVariantsTemplatesExt<Args extends Obj, ArgsExtra extends Obj> = TestVariantsTemplates<{
+    [key in ArgName<Args | ArgsExtra>]: key extends ArgName<Args> ? Args[key] : key extends ArgName<ArgsExtra> ? ArgsExtra[key] : never;
+}>;

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/caches.d.ts

@@ -0,0 +1 @@
+export declare function getArgName(argIndex: number): string;

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/check.d.ts

@@ -0,0 +1,2 @@
+import { VariantNavigationState } from '../../../types';
+export declare function checkVariantNavigationState(state: VariantNavigationState<any>, valuesPattern: string, indexesPattern: string | null, limitPattern: string): void;

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/create.d.ts

@@ -0,0 +1,3 @@
+import { TestVariantsTemplates, VariantNavigationState } from '../../../types';
+export declare function createArgs(indexes: number[], templates: TestVariantsTemplates<any>): any;
+export declare function _createVariantNavigationState(argsPattern: string, extraPattern: string, limitPattern: string, valuesAsFuncs?: boolean): VariantNavigationState<any>;

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/format.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from '@flemist/simple-utils';
+import { VariantNavigationState } from '../../../types';
+export declare function formatIndexes(indexes: number[]): string;
+export declare function formatLimits(limits: (number | null)[]): string;
+export declare function formatTemplatesValues(argValues: (readonly Ref<number>[])[]): string;
+export declare function formatState(state: VariantNavigationState<any>): string;

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/parse.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from '@flemist/simple-utils';
+import { TestVariantsTemplates, TestVariantsTemplatesExtra } from '../../../types';
+export declare function parseIndexes(numberPattern: string): number[];
+export declare function parseLimits(numberPattern: string): (number | null)[];
+export declare function parseTemplates(argsPattern: string, valuesAsFuncs: boolean): TestVariantsTemplates<any>;
+export declare function parseTemplatesValues(argsPattern: string): Ref<number>[][];
+export declare function parseTemplatesExtra(extraPattern: string): TestVariantsTemplatesExtra<any>;
+export declare function parseExtraCounts(extraPattern: string, argIndex: number): number[];

package/build/common/test-variants/iterator/variant-navigation/-test/helpers/variants.d.ts

@@ -0,0 +1,12 @@
+import { LimitArgOnError } from '../../../../..';
+import { VariantNavigationState } from '../../../types';
+export type ComplexArgs = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare function createComplexState(extraPattern: string, limitArgOnError: null | boolean | LimitArgOnError, includeErrorVariant: boolean): VariantNavigationState<ComplexArgs>;
+export declare function collectAllVariants(extraPattern: string): string[];
+export declare const funcTrue: () => boolean;
+export declare const funcFalse: () => boolean;

package/build/common/test-variants/iterator/variant-navigation/variantNavigation.d.ts

@@ -0,0 +1,28 @@
+import { Obj } from '@flemist/simple-utils';
+import { ArgName, TestVariantsTemplatesWithExtra, VariantNavigationState } from '../types';
+import { LimitArgOnError } from '../../..';
+import { Equals } from '../../types';
+/** Create initial variant navigation state for given templates */
+export declare function createVariantNavigationState<Args extends Obj, Extra extends Obj>(templates: TestVariantsTemplatesWithExtra<Args, Extra>, equals: null | Equals, limitArgOnError: null | boolean | LimitArgOnError, includeErrorVariant: null | boolean): VariantNavigationState<Args>;
+/** Calculate template values for given arg name */
+export declare function calcArgValues<Args extends Obj>(state: VariantNavigationState<Args>, argName: ArgName<Args>): readonly any[];
+/** Get max possible arg value index, considering limits */
+export declare function getArgValueMaxIndex(state: VariantNavigationState<any>, argIndex: number, belowMax: boolean): number;
+/** Reset variant navigation to initial state; variant position will be undefined */
+export declare function resetVariantNavigation<Args extends Obj>(state: VariantNavigationState<Args>): void;
+/** Advance to next variant in cartesian product; returns true if successful */
+export declare function advanceVariantNavigation<Args extends Obj>(state: VariantNavigationState<Args>): boolean;
+/** Retreat to previous variant (decrement with borrow); returns true if successful */
+export declare function retreatVariantNavigation<Args extends Obj>(state: VariantNavigationState<Args>): boolean;
+/**
+ * Compute indexes for all args
+ * @return null if any arg value not found or out of limits
+ */
+export declare function calcArgsIndexes<Args extends Obj>(state: VariantNavigationState<Args>, targetArgs: Args): number[] | null;
+/**
+ * Random pick within limits; returns true if successful
+ * If the random variant turned out to be invalid,
+ * then we try to perform the advance or retreat operation,
+ * and they return the final result.
+ */
+export declare function randomVariantNavigation<Args extends Obj>(state: VariantNavigationState<Args>): boolean;

package/build/common/test-variants/log/format.d.ts

@@ -0,0 +1,7 @@
+import { ModeConfig } from '../types';
+/** Format duration in human-readable form */
+export declare function formatDuration(ms: number): string;
+/** Format bytes in human-readable form */
+export declare function formatBytes(bytes: number): string;
+/** Format mode config for logging */
+export declare function formatModeConfig(modeConfig: ModeConfig | null, modeIndex: number): string;

package/build/common/test-variants/log/getMemoryUsage.d.ts

@@ -0,0 +1,2 @@
+/** Get current memory usage (Node.js or Chrome) */
+export declare function getMemoryUsage(): number | null;

package/build/common/test-variants/log/logOptions.d.ts

@@ -0,0 +1,8 @@
+import { TestVariantsLogOptions } from '../types';
+import { RequiredNonNullable } from '@flemist/simple-utils';
+/** Default log options when logging is enabled */
+export declare const logOptionsDefault: RequiredNonNullable<TestVariantsLogOptions>;
+/** Log options when logging is disabled */
+export declare const logOptionsDisabled: RequiredNonNullable<TestVariantsLogOptions>;
+/** Resolve log options from various input formats */
+export declare function resolveLogOptions(logRaw: boolean | TestVariantsLogOptions | null | undefined): RequiredNonNullable<TestVariantsLogOptions>;

package/build/common/test-variants/run/AbortErrorSilent.d.ts

@@ -0,0 +1,3 @@
+import { AbortError } from '@flemist/abort-controller-fast';
+export declare class AbortErrorSilent extends AbortError {
+}