@dbs-portal/tool-mock/dist/factories/base.js

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Base factory functions for creating mock data
 */
/**
 * Create a data factory function
 */
export function createDataFactory(template, options = {}) {
    return (overrides) => {
        // Set seed if provided for reproducible generation
        if (options.seed !== undefined) {
            seedRandom(options.seed);
        }
        return template(overrides);
    };
}
/**
 * Create a list factory function
 */
export function createListFactory(itemFactory, defaultCount = 10) {
    return (count, overrides) => {
        const itemCount = count ?? defaultCount;
        const items = [];
        for (let i = 0; i < itemCount; i++) {
            items.push(itemFactory(overrides));
        }
        return items;
    };
}
/**
 * Create a typed factory with TypeScript support
 */
export function createTypedFactory(template) {
    return createDataFactory(template);
}
/**
 * Combine multiple factories into one
 */
export function combineFactories(...factories) {
    return (overrides) => {
        let result = {};
        // Apply each factory
        for (const factory of factories) {
            const partial = factory();
            result = { ...result, ...partial };
        }
        // Apply overrides
        if (overrides) {
            result = { ...result, ...overrides };
        }
        return result;
    };
}
/**
 * Create a factory that extends another factory
 */
export function extendFactory(baseFactory, extension) {
    return (overrides) => {
        const base = baseFactory();
        return extension(base, overrides);
    };
}
/**
 * Create a conditional factory
 */
export function conditionalFactory(condition, trueFactory, falseFactory) {
    return (overrides) => {
        const factory = condition() ? trueFactory : falseFactory;
        return factory(overrides);
    };
}
/**
 * Create a weighted factory (randomly selects from multiple factories)
 */
export function weightedFactory(factories) {
    return (overrides) => {
        const totalWeight = factories.reduce((sum, item) => sum + item.weight, 0);
        const random = Math.random() * totalWeight;
        let currentWeight = 0;
        for (const item of factories) {
            currentWeight += item.weight;
            if (random <= currentWeight) {
                return item.factory(overrides);
            }
        }
        // Fallback to first factory
        return factories[0]?.factory(overrides) || {};
    };
}
/**
 * Create a sequence factory (cycles through values)
 */
export function sequenceFactory(values, startIndex = 0) {
    let currentIndex = startIndex;
    return () => {
        if (values.length === 0) {
            throw new Error('Cannot create sequence from empty array');
        }
        const value = values[currentIndex % values.length];
        currentIndex++;
        return value;
    };
}
/**
 * Create a unique factory (ensures unique values)
 */
export function uniqueFactory(factory, keyExtractor = (item) => JSON.stringify(item), maxAttempts = 100) {
    const usedKeys = new Set();
    return (overrides) => {
        for (let attempt = 0; attempt < maxAttempts; attempt++) {
            const item = factory(overrides);
            const key = keyExtractor(item);
            if (!usedKeys.has(key)) {
                usedKeys.add(key);
                return item;
            }
        }
        // If we can't generate a unique value, return the last attempt
        console.warn('Could not generate unique value after', maxAttempts, 'attempts');
        return factory(overrides);
    };
}
/**
 * Create a cached factory (caches results)
 */
export function cachedFactory(factory, cacheSize = 100) {
    const cache = new Map();
    const cacheKeys = [];
    return (overrides) => {
        const key = JSON.stringify(overrides || {});
        if (cache.has(key)) {
            return cache.get(key);
        }
        const item = factory(overrides);
        // Manage cache size
        if (cache.size >= cacheSize) {
            const oldestKey = cacheKeys.shift();
            if (oldestKey) {
                cache.delete(oldestKey);
            }
        }
        cache.set(key, item);
        cacheKeys.push(key);
        return item;
    };
}
/**
 * Create a factory with validation
 */
export function validatedFactory(factory, validator, maxAttempts = 10) {
    return (overrides) => {
        for (let attempt = 0; attempt < maxAttempts; attempt++) {
            const item = factory(overrides);
            if (validator(item)) {
                return item;
            }
        }
        // If validation keeps failing, return the last attempt
        console.warn('Factory validation failed after', maxAttempts, 'attempts');
        return factory(overrides);
    };
}
/**
 * Create a factory that tracks generation statistics
 */
export function instrumentedFactory(factory, onGenerate) {
    let count = 0;
    let totalTime = 0;
    return (overrides) => {
        const startTime = performance.now();
        const item = factory(overrides);
        const endTime = performance.now();
        count++;
        totalTime += endTime - startTime;
        if (onGenerate) {
            onGenerate(item, { count, totalTime });
        }
        return item;
    };
}
/**
 * Simple seeded random number generator
 */
let randomSeed = 1;
function seedRandom(seed) {
    randomSeed = seed;
}
function seededRandom() {
    const x = Math.sin(randomSeed++) * 10000;
    return x - Math.floor(x);
}
/**
 * Get seeded random number (if seed was set)
 */
export function getRandom() {
    return randomSeed > 1 ? seededRandom() : Math.random();
}
/**
 * Reset random seed
 */
export function resetRandomSeed() {
    randomSeed = 1;
}
//# sourceMappingURL=base.js.map