alwz/build/esm/utils.mjs

Extendable library for typecasting

import EV from './models/ErrorValue.mjs';
import Converter, { assertFallback, isConversion, assertConversion } from './models/Converter.mjs';
import * as presets from './presets.mjs';
const InvalidArgument = class extends EV {
};
export const array = (conversion, initiator = presets.array.convert) => {
    assertConversion(conversion);
    if (!isConversion(initiator)) {
        throw new Converter.InvalidConversionFunction('initiator must be a function', initiator);
    }
    return (input) => {
        return initiator(input).map(conversion);
    };
};
export const tuple = (conversions, initiator = presets.array.convert) => {
    if (!Array.isArray(conversions)) {
        throw new Converter.InvalidConversionFunction('first argument must be an array', conversions);
    }
    conversions.forEach((conversion, index) => {
        if (!isConversion(conversion)) {
            throw new Converter.InvalidConversionFunction('conversion ' + index + ' must be a function', [index, conversion]);
        }
    });
    if (!isConversion(initiator)) {
        throw new Converter.InvalidConversionFunction('initiator must be a function', initiator);
    }
    return (input) => {
        const array = initiator(input);
        return conversions.map((fn, index) => fn(array[index]));
    };
};
export const range = (lower = -Number.MAX_VALUE, upper = Number.MAX_VALUE, fallback, conversion = presets.double.convert) => {
    assertConversion(conversion);
    lower = conversion(lower);
    upper = conversion(upper);
    const fallbackActual = fallback === undefined
        ? (input) => {
            const converted = conversion(input);
            return upper <= converted ? upper : lower;
        }
        : fallback;
    assertFallback(fallbackActual);
    return (input) => {
        const converted = conversion(input);
        if ((lower <= converted) && (converted <= upper)) {
            return converted;
        }
        return fallbackActual(input);
    };
};
export const variant = (values, fallback = () => values[0], conversion = presets.double.convert) => {
    assertConversion(conversion);
    assertFallback(fallback);
    if (!Array.isArray(values)) {
        throw new InvalidArgument('variant values must be an array of allowed values', values);
    }
    values = values.map((value) => conversion(value));
    return (input) => {
        const converted = conversion(input);
        if (values.includes(converted)) {
            return converted;
        }
        return fallback(input);
    };
};
export const object = (schema, conversion = presets.object.convert) => {
    if (typeof schema !== 'object' || schema === null) {
        throw new InvalidArgument('schema must must be an object', schema);
    }
    for (const key in schema) {
        const conversion = schema[key];
        assertConversion(conversion);
    }
    assertConversion(conversion);
    return (input) => {
        const result = {};
        const source = conversion(input);
        for (const key in schema) {
            const type = schema[key];
            result[key] = type(source === null || source === void 0 ? void 0 : source[key]);
        }
        return result;
    };
};
export const dictionary = (conversion, initiator = presets.object.convert) => {
    if (typeof conversion !== 'function') {
        throw new InvalidArgument('conversion must be a function', conversion);
    }
    assertConversion(initiator);
    return (input) => {
        const result = {};
        const source = initiator(input);
        for (const key in source) {
            result[key] = conversion(source === null || source === void 0 ? void 0 : source[key], key);
        }
        return result;
    };
};
export const projection = (schema) => {
    const builders = Object
        .entries(schema)
        .map(([key, value]) => {
        if (typeof value === 'function') {
            return [key, value];
        }
        else if (value && typeof value === 'object') {
            return [key, projection(value)];
        }
        else {
            throw new EV('invalid schema item', { key, value });
        }
    });
    return function (source, options) {
        return builders
            .reduce((target, [key, build]) => {
            target[key] = build.call(this, source, options, target);
            return target;
        }, {});
    };
};
//# sourceMappingURL=utils.mjs.map