ts-cast/esm/engine/index.js

Runtime typechecking

import { restrict } from './restrict';
import optional from './optional';
import required from './required';
import map from './map';
import defValue from './default';
import { nullable } from './nullable';
import either from './either';
import { validate, validation } from './validate';
import { memo } from '../helpers/memo0';
import { toBe } from './to-be';
export { is } from './is';
export const casterApi = (casterFn) => Object.defineProperties(casterFn, Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(casterFn)), { optional: {
        enumerable: true,
        get: memo(() => casterApi(optional(casterFn))),
    }, nullable: {
        enumerable: true,
        get: memo(() => casterApi(nullable(casterFn))),
    }, restrict: {
        enumerable: true,
        value: (...rules) => casterApi(restrict(casterFn, rules)),
    }, map: {
        enumerable: true,
        value: (transform) => casterApi(map(casterFn, transform)),
    }, default: {
        enumerable: true,
        value: (def) => casterApi(defValue(casterFn, def)),
    }, either: {
        enumerable: true,
        value: (leftFactory, rightFactory) => either(casterFn, leftFactory, rightFactory),
    }, validation: {
        enumerable: true,
        value: (invalidFactory, validFactory) => validation(casterFn, invalidFactory, validFactory),
    }, validate: {
        enumerable: true,
        get: memo(() => validate(casterFn)),
    }, toBe: {
        enumerable: true,
        value: (predicate, typeName) => casterApi(toBe(casterFn, predicate, typeName)),
    } }));
export const createCaster = (typeName, typeGuard, transform) => casterApi(required(typeName, typeGuard, transform));