alwz/build/esm/presets.mjs

Extendable library for typecasting

import Converter from './models/Converter.mjs';
import * as numbers from './constants/numbers.mjs';
import is, { integers as intIs, floats as floatIs } from './is.mjs';
const boolean = new Converter(is.boolean, Boolean)
    .undefined(Boolean)
    .number(Boolean)
    .bigint(Boolean)
    .string(Boolean)
    .symbol(function (i) { return this.convert(string.convert(i)); })
    .register(is.null, Boolean)
    .register(is.Array, function (i) { return this.convert(i[0]); })
    .register(is.Date, (i) => Boolean(i.getTime()));
const number = new Converter(is.number, Number)
    .undefined(Number)
    .boolean(Number)
    .bigint(Number)
    .string(Number)
    .symbol((i) => Number(string.convert(i)))
    .register(is.null, () => 0)
    .register(is.Array, function (i) { return this.convert(i[0]); })
    .register(is.Date, (i) => i.getTime());
const numeric = number.clone()
    .undefined(() => 0)
    .bigint(function (i) { return this.convert(Number(i)); })
    .string(function (i) { return this.convert(Number(i)); })
    .symbol(function (i) { return this.convert(string.convert(i)); })
    .register(is.Date, function (i) { return this.convert(i.getTime()); });
numeric.fallback = () => 0;
export const integers = Object.fromEntries(Object.entries(numbers.integers)
    .map(([name, [min, max]]) => {
    const converter = numeric.clone()
        .number(function (i) {
        if (i <= min) {
            return min;
        }
        else if (i >= max) {
            return max;
        }
        else if (Number.isNaN(i)) {
            return 0;
        }
        else {
            return Math.trunc(i);
        }
    });
    converter.is = intIs[name];
    return [name, converter];
}));
export const floats = Object.fromEntries(Object.entries(numbers.floats)
    .map(([name, [min, max]]) => {
    const converter = numeric.clone()
        .number(function (i) {
        if (i >= max) {
            return max;
        }
        else if (i <= min) {
            return min;
        }
        else {
            return 0;
        }
    });
    converter.is = floatIs[name];
    return [name, converter];
}));
const bigint = new Converter(is.bigint, () => BigInt(0))
    .undefined(() => BigInt(0))
    .boolean((i) => BigInt(i))
    .number((i) => BigInt(Math.trunc(floats.double.convert(i))))
    .string(function (i) { return this.convert(Number(i)); })
    .symbol(function (i) { return this.convert(string.convert(i)); })
    .register(is.null, () => BigInt(0))
    .register(is.Array, function (i) { return this.convert(i[0]); })
    .register(is.Date, function (i) { return this.convert(i.getTime()); });
const string = new Converter(is.string, String)
    .undefined(() => '')
    .boolean((i) => i ? ' ' : '')
    .number((i) => i === i ? String(i) : '')
    .bigint(String)
    .symbol((i) => Symbol.keyFor(i) || '')
    .register(is.null, () => '')
    .register(is.Array, function (i) { return this.convert(i[0]); })
    .register(is.Date, function (i) {
    const ts = i.getTime();
    if (Number.isFinite(ts)) {
        return i.toISOString();
    }
    else {
        return new Date(0).toISOString();
    }
});
const symbol = new Converter(is.symbol, (i) => Symbol.for(string.convert(i)));
const array = new Converter(is.Array, (i) => ([i]))
    .undefined(() => [])
    .boolean((i) => [i])
    .number((i) => [i])
    .bigint((i) => [i])
    .string((i) => [i])
    .symbol((i) => [i])
    .register(is.null, () => [])
    .register(is.Iterable, Array.from);
const fn = new Converter(is.function, (i) => () => i);
const date = new Converter(is.Date, () => new Date(NaN))
    .undefined(() => new Date(NaN))
    .boolean((i) => new Date(Number(i)))
    .number((i) => new Date(i))
    .bigint((i) => new Date(Number(i)))
    .string((i) => new Date(i))
    .symbol((i) => new Date(string.convert(i)))
    .register(is.Array, function (i) { return this.convert(i[0]); });
const object = new Converter(is.object, Object);
const map = new Converter(is.Map, () => new Map())
    .register(is.Iterable, (input) => {
    const result = new Map();
    for (const item of input) {
        if (is.Iterable(item)) {
            const [key, value] = item;
            result.set(key, value);
        }
    }
    return result;
});
const weakmap = new Converter(is.WeakMap, () => new WeakMap())
    .register(is.Iterable, (input) => {
    const result = new WeakMap();
    for (const item of input) {
        if (is.Iterable(item)) {
            const [key, value] = item;
            if ((typeof key === 'object' && key !== null) || typeof key === 'function') {
                result.set(key, value);
            }
        }
    }
    return result;
});
const set = new Converter(is.Set, (i) => new Set().add(i))
    .undefined(() => new Set())
    .register(is.null, () => new Set())
    .register(is.Iterable, (i) => new Set(i));
const weakset = new Converter(is.WeakSet, () => new WeakSet())
    .register(is.Iterable, (i) => {
    const result = new WeakSet();
    for (const item of i) {
        if ((typeof item === 'object' && item !== null) || typeof item === 'function') {
            result.add(item);
        }
    }
    return result;
});
const promise = new Converter(is.Promise, (i) => Promise.resolve(i));
export default Object.assign(Object.assign(Object.assign({ boolean,
    number }, integers), floats), { bigint,
    string,
    symbol,
    array,
    fn,
    date,
    object,
    map,
    weakmap,
    set,
    weakset,
    promise });
//# sourceMappingURL=presets.mjs.map