@flemist/test-variants 3.0.3 → 5.0.0

package/dist/lib/test-variants/testVariantsIterator.cjs

@@ -1,429 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/** Find last index of value in array; uses custom equals or strict equality */
-function findLastIndex(values, value, equals) {
-    if (equals) {
-        for (let i = values.length - 1; i >= 0; i--) {
-            if (equals(values[i], value)) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] === value) {
-            return i;
-        }
-    }
-    return -1;
-}
-/** Calculate template values for given key index */
-function calcTemplateValues(templates, args, keyIndex) {
-    const template = templates[keyIndex];
-    if (typeof template === 'function') {
-        return template(args);
-    }
-    return template;
-}
-/** Reset iterator state for new cycle */
-function resetIteratorState(state, templates, keysCount) {
-    state.index = -1;
-    state.repeatIndex = 0;
-    for (let i = 0; i < keysCount; i++) {
-        state.indexes[i] = -1;
-        state.argValues[i] = [];
-    }
-    if (keysCount > 0) {
-        state.argValues[0] = calcTemplateValues(templates, state.args, 0);
-    }
-}
-/** Get effective max index for an arg (considering argLimit) */
-function getMaxIndex(state, keyIndex) {
-    const valuesLen = state.argValues[keyIndex].length;
-    const argLimit = state.argLimits[keyIndex];
-    if (argLimit == null) {
-        return valuesLen;
-    }
-    return argLimit < valuesLen ? argLimit : valuesLen;
-}
-/** Advance to next variant in cartesian product; returns true if successful */
-function advanceVariant(state, templates, keys, keysCount) {
-    var _a;
-    for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
-        const valueIndex = state.indexes[keyIndex] + 1;
-        const maxIndex = getMaxIndex(state, keyIndex);
-        if (valueIndex < maxIndex) {
-            const key = keys[keyIndex];
-            const value = state.argValues[keyIndex][valueIndex];
-            state.indexes[keyIndex] = valueIndex;
-            state.args[key] = value;
-            for (keyIndex++; keyIndex < keysCount; keyIndex++) {
-                const keyVariants = calcTemplateValues(templates, state.args, keyIndex);
-                const keyMaxIndex = (_a = state.argLimits[keyIndex]) !== null && _a !== void 0 ? _a : keyVariants.length;
-                if (keyVariants.length === 0 || keyMaxIndex <= 0) {
-                    break;
-                }
-                state.indexes[keyIndex] = 0;
-                state.argValues[keyIndex] = keyVariants;
-                const key = keys[keyIndex];
-                const value = keyVariants[0];
-                state.args[key] = value;
-            }
-            if (keyIndex >= keysCount) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/** Validate saved args keys match iterator's arg names (ignoring "seed" key) */
-function validateArgsKeys(savedArgs, keysSet, keysCount) {
-    const savedKeys = Object.keys(savedArgs).filter(k => k !== 'seed');
-    if (savedKeys.length !== keysCount) {
-        return false;
-    }
-    for (const key of savedKeys) {
-        if (!keysSet.has(key)) {
-            return false;
-        }
-    }
-    return true;
-}
-/** For static templates, verify arg value exists in template values */
-function validateStaticArgsValues(savedArgs, templates, keys, keysCount, equals) {
-    for (let i = 0; i < keysCount; i++) {
-        const template = templates[i];
-        if (typeof template !== 'function') {
-            const value = savedArgs[keys[i]];
-            if (findLastIndex(template, value, equals) < 0) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/** Check if current position >= pending args position; returns false if current < pending or all args skipped */
-function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
-    let anyCompared = false;
-    for (let i = 0; i < keysCount; i++) {
-        const currentValueIndex = state.indexes[i];
-        const pendingValue = pendingArgs[keys[i]];
-        const pendingValueIndex = findLastIndex(state.argValues[i], pendingValue, equals);
-        // Dynamic template value not found - skip this arg from comparison
-        if (pendingValueIndex < 0) {
-            continue;
-        }
-        anyCompared = true;
-        if (currentValueIndex < pendingValueIndex) {
-            return false;
-        }
-        if (currentValueIndex > pendingValueIndex) {
-            return true;
-        }
-    }
-    // All compared args are equal - position reached; or all args skipped - keep pending
-    return anyCompared;
-}
-/** Calculate indexes for given args; returns null if any value not found */
-function calcArgsIndexes(limitArgs, templates, keys, keysCount, equals) {
-    const indexes = [];
-    for (let i = 0; i < keysCount; i++) {
-        const key = keys[i];
-        const value = limitArgs[key];
-        // Use limitArgs for dynamic template calculation
-        const values = calcTemplateValues(templates, limitArgs, i);
-        const valueIndex = findLastIndex(values, value, equals);
-        if (valueIndex < 0) {
-            return null;
-        }
-        indexes.push(valueIndex);
-    }
-    return indexes;
-}
-/** Compare two index arrays lexicographically; returns -1 if a < b, 0 if equal, 1 if a > b */
-function compareLexicographic(a, b) {
-    var _a, _b;
-    const len = Math.max(a.length, b.length);
-    for (let i = 0; i < len; i++) {
-        const ai = (_a = a[i]) !== null && _a !== void 0 ? _a : 0;
-        const bi = (_b = b[i]) !== null && _b !== void 0 ? _b : 0;
-        if (ai < bi) {
-            return -1;
-        }
-        if (ai > bi) {
-            return 1;
-        }
-    }
-    return 0;
-}
-/** Update per-arg limits from args values using lexicographic comparison; returns true if updated */
-function updateArgLimits(state, limitArgs, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError) {
-    if (!limitArgOnError) {
-        return false;
-    }
-    // Calculate indexes for new limit args
-    const newIndexes = calcArgsIndexes(limitArgs, templates, keys, keysCount, equals);
-    if (!newIndexes) {
-        return false; // Value not found, can't apply limit
-    }
-    // If we have existing limit, compare lexicographically
-    if (oldLimitArgs) {
-        const currentIndexes = calcArgsIndexes(oldLimitArgs, templates, keys, keysCount, equals);
-        if (currentIndexes) {
-            const cmp = compareLexicographic(newIndexes, currentIndexes);
-            if (cmp >= 0) {
-                // New is larger or equal - reject entirely
-                return false;
-            }
-        }
-    }
-    // New is smaller (or first limit) - replace all argLimits
-    for (let i = 0; i < keysCount; i++) {
-        const valueIndex = newIndexes[i];
-        // Check callback if provided
-        if (typeof limitArgOnError === 'function') {
-            const key = keys[i];
-            const values = calcTemplateValues(templates, limitArgs, i);
-            const shouldLimit = limitArgOnError({
-                name: key,
-                valueIndex,
-                values,
-                maxValueIndex: state.argLimits[i],
-            });
-            if (!shouldLimit) {
-                state.argLimits[i] = null;
-                continue;
-            }
-        }
-        // Set argLimit: index 0 can't be limited further, store null
-        state.argLimits[i] = valueIndex > 0 ? valueIndex : null;
-    }
-    // Filter out pending limits that are now excluded by argLimits
-    state.pendingLimits = state.pendingLimits.filter(pending => {
-        for (let i = 0; i < keysCount; i++) {
-            const value = pending.args[keys[i]];
-            const values = calcTemplateValues(templates, pending.args, i);
-            const valueIndex = findLastIndex(values, value, equals);
-            const argLimit = state.argLimits[i];
-            if (argLimit != null && valueIndex >= argLimit) {
-                return false; // Pending position is excluded by argLimits
-            }
-        }
-        return true; // Keep
-    });
-    return true;
-}
-/** Process pending limits; returns true if any limit was applied */
-function processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError) {
-    var _a, _b;
-    let applied = false;
-    for (let i = state.pendingLimits.length - 1; i >= 0; i--) {
-        const pending = state.pendingLimits[i];
-        if (isPositionReached(state, pending.args, keys, keysCount, equals)) {
-            // Current position >= pending position: apply limit
-            if (state.count == null || state.index < state.count) {
-                const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
-                state.count = state.index;
-                state.limit = typeof pending.error !== 'undefined'
-                    ? { args: pending.args, error: pending.error }
-                    : { args: pending.args };
-                updateArgLimits(state, pending.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
-                applied = true;
-            }
-            // Remove from pending
-            state.pendingLimits.splice(i, 1);
-        }
-    }
-    return applied;
-}
-/** Creates test variants iterator with limiting capabilities */
-function testVariantsIterator(options) {
-    const { argsTemplates, getSeed, repeatsPerVariant: _repeatsPerVariant, equals, limitArgOnError } = options;
-    const repeatsPerVariant = _repeatsPerVariant !== null && _repeatsPerVariant !== void 0 ? _repeatsPerVariant : 1;
-    const keys = Object.keys(argsTemplates);
-    const templates = Object.values(argsTemplates);
-    const keysCount = keys.length;
-    const keysSet = new Set(keys);
-    // Initialize state
-    const indexes = [];
-    const argValues = [];
-    const argLimits = [];
-    for (let i = 0; i < keysCount; i++) {
-        indexes[i] = -1;
-        argValues[i] = [];
-        argLimits[i] = null;
-    }
-    const state = {
-        args: {},
-        indexes,
-        argValues,
-        argLimits,
-        index: -1,
-        cycleIndex: -1,
-        repeatIndex: 0,
-        count: null,
-        limit: null,
-        started: false,
-        currentArgs: null,
-        pendingLimits: [],
-    };
-    const iterator = {
-        get index() {
-            return state.index;
-        },
-        get cycleIndex() {
-            return state.cycleIndex;
-        },
-        get count() {
-            return state.count;
-        },
-        get limit() {
-            return state.limit;
-        },
-        addLimit(_options) {
-            var _a, _b, _c, _d, _e, _f;
-            const hasArgs = typeof (_options === null || _options === void 0 ? void 0 : _options.args) !== 'undefined' && _options.args !== null;
-            const hasIndex = (_options === null || _options === void 0 ? void 0 : _options.index) != null;
-            // addLimit() or addLimit({error}) - uses current args and index
-            if (!hasArgs && !hasIndex) {
-                if (state.index < 0) {
-                    throw new Error('[testVariantsIterator] addLimit() requires at least one next() call');
-                }
-                if (state.count == null || state.index < state.count) {
-                    const oldLimitArgs = (_b = (_a = state.limit) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : null;
-                    state.count = state.index;
-                    state.limit = typeof (_options === null || _options === void 0 ? void 0 : _options.error) !== 'undefined'
-                        ? { args: state.currentArgs, error: _options.error }
-                        : { args: state.currentArgs };
-                    updateArgLimits(state, state.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
-                }
-                return;
-            }
-            // addLimit({index}) - only index limiting, no args
-            if (hasIndex && !hasArgs) {
-                if (state.count == null || _options.index < state.count) {
-                    state.count = _options.index;
-                }
-                return;
-            }
-            // addLimit({args}) or addLimit({args, error}) - pending limit + immediate per-arg limits
-            if (hasArgs && !hasIndex) {
-                // Validate args keys match iterator's arg names
-                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
-                    return; // Discard - unreproducible (templates changed)
-                }
-                // For static templates, verify arg value exists
-                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
-                    return; // Discard - unreproducible (value not in template)
-                }
-                // Apply per-arg limits immediately (if limitArgOnError enabled)
-                const oldLimitArgs = (_d = (_c = state.limit) === null || _c === void 0 ? void 0 : _c.args) !== null && _d !== void 0 ? _d : null;
-                const updated = updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
-                if (updated) {
-                    // argLimits updated - this is the new best, update state.limit for future comparisons
-                    state.limit = typeof _options.error !== 'undefined'
-                        ? { args: _options.args, error: _options.error }
-                        : { args: _options.args };
-                    // Pending limit at this position is now filtered by argLimits, don't add
-                }
-                else if (!limitArgOnError) {
-                    // No argLimits filtering - add pending limit for position-based stopping
-                    const pending = typeof _options.error !== 'undefined'
-                        ? { args: _options.args, error: _options.error }
-                        : { args: _options.args };
-                    state.pendingLimits.push(pending);
-                }
-                // If limitArgOnError and not updated (lexicographically larger), discard entirely
-                return;
-            }
-            // addLimit({args, index}) or addLimit({args, index, error}) - immediate index + pending args
-            if (hasArgs && hasIndex) {
-                // Check if this is earliest (before potentially updating count)
-                const isEarliest = state.count == null || _options.index < state.count;
-                // Always apply index limit
-                if (isEarliest) {
-                    state.count = _options.index;
-                }
-                // Validate args for limit property update
-                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
-                    return; // Skip per-arg limits and limit property update
-                }
-                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
-                    return; // Skip per-arg limits and limit property update
-                }
-                // Update limit if this is earliest
-                if (isEarliest) {
-                    const oldLimitArgs = (_f = (_e = state.limit) === null || _e === void 0 ? void 0 : _e.args) !== null && _f !== void 0 ? _f : null;
-                    state.limit = typeof _options.error !== 'undefined'
-                        ? { args: _options.args, error: _options.error }
-                        : { args: _options.args };
-                    updateArgLimits(state, _options.args, oldLimitArgs, templates, keys, keysCount, equals, limitArgOnError);
-                }
-            }
-        },
-        start() {
-            state.cycleIndex++;
-            resetIteratorState(state, templates, keysCount);
-            state.started = true;
-        },
-        next() {
-            if (!state.started) {
-                throw new Error('[testVariantsIterator] start() must be called before next()');
-            }
-            // Try next repeat for current variant
-            if (state.index >= 0 && state.repeatIndex + 1 < repeatsPerVariant) {
-                // Check if current variant is still within limit
-                if (state.count == null || state.index < state.count) {
-                    state.repeatIndex++;
-                    if (getSeed) {
-                        const seed = getSeed({
-                            variantIndex: state.index,
-                            cycleIndex: state.cycleIndex,
-                            repeatIndex: state.repeatIndex,
-                        });
-                        state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
-                    }
-                    else {
-                        state.currentArgs = Object.assign({}, state.args);
-                    }
-                    return state.currentArgs;
-                }
-            }
-            // Move to next variant
-            state.repeatIndex = 0;
-            if (!advanceVariant(state, templates, keys, keysCount)) {
-                // First complete cycle sets count to total variant count
-                if (state.count == null) {
-                    state.count = state.index + 1;
-                }
-                return null;
-            }
-            state.index++;
-            // Process pending limits at new position
-            if (state.pendingLimits.length > 0) {
-                processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError);
-            }
-            // Check count limit (may have been updated by pending limit)
-            if (state.count != null && state.index >= state.count) {
-                return null;
-            }
-            if (getSeed) {
-                const seed = getSeed({
-                    variantIndex: state.index,
-                    cycleIndex: state.cycleIndex,
-                    repeatIndex: state.repeatIndex,
-                });
-                state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
-            }
-            else {
-                state.currentArgs = Object.assign({}, state.args);
-            }
-            return state.currentArgs;
-        },
-    };
-    return iterator;
-}
-
-exports.testVariantsIterator = testVariantsIterator;

package/dist/lib/test-variants/testVariantsIterator.d.ts

@@ -1,67 +0,0 @@
-import type { Obj } from "./types";
-import type { TestVariantsTemplate, TestVariantsTemplates } from "./testVariantsIterable";
-/** Parameters passed to getSeed function for generating test seeds */
-export declare type GetSeedParams = {
-    /** Index of current variant/parameter-combination being tested */
-    variantIndex: number;
-    /** Index of current cycle - full pass through all variants (0..cycles-1) */
-    cycleIndex: number;
-    /** Index of repeat for current variant within this cycle (0..repeatsPerVariant-1) */
-    repeatIndex: number;
-};
-/** Options for limiting per-arg indexes on error */
-export declare type LimitArgOnErrorOptions = {
-    /** Arg name */
-    name: string;
-    /** Arg value's index in template values array */
-    valueIndex: number;
-    /** Current template values array for this arg */
-    values: any[];
-    /** Current max value index limit for this arg; null if no limit */
-    maxValueIndex: number | null;
-};
-/** Callback to decide whether to apply limit for specific arg */
-export declare type LimitArgOnError = (options: LimitArgOnErrorOptions) => boolean;
-/** Options for creating test variants iterator */
-export declare type TestVariantsIteratorOptions<Args extends Obj> = {
-    argsTemplates: TestVariantsTemplates<Args>;
-    /** Custom equality for comparing arg values */
-    equals?: null | ((a: any, b: any) => boolean);
-    /** Limit per-arg indexes on error; boolean enables/disables, function for custom per-arg logic */
-    limitArgOnError?: null | boolean | LimitArgOnError;
-    /** Generates seed for reproducible randomized testing; seed is added to args */
-    getSeed?: null | ((params: GetSeedParams) => any);
-    /** Number of repeat tests per variant within each cycle */
-    repeatsPerVariant?: null | number;
-};
-/** Limit information with args and optional error */
-export declare type TestVariantsIteratorLimit<Args> = {
-    args: Args;
-    error?: unknown;
-};
-/** Options for addLimit method */
-export declare type AddLimitOptions<Args> = {
-    args?: null | Args;
-    index?: null | number;
-    error?: unknown;
-};
-/** Test variants iterator with limiting capabilities */
-export declare type TestVariantsIterator<Args extends Obj> = {
-    /** Current variant index; -1 before first next() */
-    readonly index: number;
-    /** Current cycle index; starts at 0 after first start() */
-    readonly cycleIndex: number;
-    /** Maximum variant count; variants with index >= count are not yielded */
-    readonly count: number | null;
-    /** Last applied limit's args and error; null if no args-based limit applied */
-    readonly limit: TestVariantsIteratorLimit<Args> | null;
-    /** Add or tighten limit */
-    addLimit(options?: null | AddLimitOptions<Args>): void;
-    /** Reset to beginning of iteration for next cycle */
-    start(): void;
-    /** Get next variant or null when done */
-    next(): Args | null;
-};
-export { type TestVariantsTemplate, type TestVariantsTemplates, };
-/** Creates test variants iterator with limiting capabilities */
-export declare function testVariantsIterator<Args extends Obj>(options: TestVariantsIteratorOptions<Args>): TestVariantsIterator<Args>;