@typed/fp/cjs/DecodeError.js

Data Structures and Resources for fp-ts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.drawErrors = exports.drawError = exports.getSemigroup = exports.match = exports.wrap = exports.lazy = exports.member = exports.unexpectedIndexes = exports.missingIndexes = exports.index = exports.unexpectedKeys = exports.missingKeys = exports.key = exports.leaf = void 0;
const tslib_1 = require("tslib");
/**
 * DecodeError representation of the various errors that might occur while decoding.
 * @since 0.9.4
 */
const function_1 = require("fp-ts/function");
const RA = (0, tslib_1.__importStar)(require("fp-ts/ReadonlyArray"));
const T = (0, tslib_1.__importStar)(require("fp-ts/Tree"));
/**
 * @category constructors
 * @since 0.9.4
 */
const leaf = (actual, error) => ({
    _tag: 'Leaf',
    actual,
    error,
});
exports.leaf = leaf;
/**
 * @category constructors
 * @since 0.9.4
 */
const key = (key, errors) => ({
    _tag: 'Key',
    key,
    errors,
});
exports.key = key;
/**
 * @category constructors
 * @since 0.9.4
 */
const missingKeys = (keys) => ({
    _tag: 'MissingKeys',
    keys,
});
exports.missingKeys = missingKeys;
/**
 * @category constructors
 * @since 0.9.4
 */
const unexpectedKeys = (keys) => ({
    _tag: 'UnexpectedKeys',
    keys,
});
exports.unexpectedKeys = unexpectedKeys;
/**
 * @category constructors
 * @since 0.9.4
 */
const index = (index, errors) => ({
    _tag: 'Index',
    index,
    errors,
});
exports.index = index;
/**
 * @category constructors
 * @since 0.9.4
 */
const missingIndexes = (indexes) => ({
    _tag: 'MissingIndexes',
    indexes,
});
exports.missingIndexes = missingIndexes;
/**
 * @category constructors
 * @since 0.9.4
 */
const unexpectedIndexes = (indexes) => ({
    _tag: 'UnexpectedIndexes',
    indexes,
});
exports.unexpectedIndexes = unexpectedIndexes;
/**
 * @category constructors
 * @since 0.9.4
 */
const member = (index, errors) => ({
    _tag: 'Member',
    index,
    errors,
});
exports.member = member;
/**
 * @category constructors
 * @since 0.9.4
 */
const lazy = (id, errors) => ({
    _tag: 'Lazy',
    id,
    errors,
});
exports.lazy = lazy;
/**
 * @category constructors
 * @since 2.2.9
 */
const wrap = (error, errors) => ({
    _tag: 'Wrap',
    error,
    errors,
});
exports.wrap = wrap;
/**
 * @category destructors
 * @since 0.9.4
 */
const match = (patterns) => {
    const f = (e) => {
        switch (e._tag) {
            case 'Leaf':
                return patterns.Leaf(e.actual, e.error);
            case 'Key':
                return patterns.Key(e.key, e.errors);
            case 'MissingKeys':
                return patterns.MissingKeys(e.keys);
            case 'UnexpectedKeys':
                return patterns.UnexpectedKeys(e.keys);
            case 'Index':
                return patterns.Index(e.index, e.errors);
            case 'MissingIndexes':
                return patterns.MissingIndexes(e.indexes);
            case 'UnexpectedIndexes':
                return patterns.UnexpectedIndexes(e.indexes);
            case 'Member':
                return patterns.Member(e.index, e.errors);
            case 'Lazy':
                return patterns.Lazy(e.id, e.errors);
            case 'Wrap':
                return patterns.Wrap(e.error, e.errors);
        }
    };
    return f;
};
exports.match = match;
/**
 * @category Typeclass Constructor
 * @since 0.9.4
 */
function getSemigroup() {
    return RA.getSemigroup();
}
exports.getSemigroup = getSemigroup;
/**
 * @category Deconstructor
 * @since 0.9.4
 */
exports.drawError = (0, function_1.flow)(toTree, T.drawTree);
/**
 * @category Deconstructor
 * @since 0.9.4
 */
exports.drawErrors = (0, function_1.flow)(RA.map((0, function_1.flow)(toTree, T.drawTree)), (ss) => ss.join('\n'));
function toForest(errors) {
    return errors.map(toTree);
}
function toTree(error) {
    return (0, function_1.pipe)(error, (0, exports.match)({
        Leaf: (i, error) => T.of(`Expected ${error} but received ${JSON.stringify(i)}`),
        Key: (key, errors) => ({ value: `Key ${key}`, forest: toForest(errors) }),
        MissingKeys: (keys) => ({ value: `MissingKeys`, forest: (0, function_1.pipe)(keys, RA.map(T.of)) }),
        UnexpectedKeys: (keys) => ({ value: `UnexpectedKeys`, forest: (0, function_1.pipe)(keys, RA.map(T.of)) }),
        Index: (Index, errors) => ({ value: `Index ${Index}`, forest: toForest(errors) }),
        MissingIndexes: (indexes) => ({
            value: `Missing indexes`,
            forest: (0, function_1.pipe)(indexes, RA.map((0, function_1.flow)(String, T.of))),
        }),
        UnexpectedIndexes: (indexes) => ({
            value: `Unexpected Indexes`,
            forest: (0, function_1.pipe)(indexes, RA.map((0, function_1.flow)(String, T.of))),
        }),
        Member: (index, errors) => ({
            value: `${index}`,
            forest: toForest(errors),
        }),
        Lazy: (id, errors) => ({
            value: id,
            forest: toForest(errors),
        }),
        Wrap: (error, errors) => ({
            value: error,
            forest: toForest(errors),
        }),
    }));
}
//# sourceMappingURL=DecodeError.js.map