@typed/fp/esm/DecodeError.js

Data Structures and Resources for fp-ts

/**
 * DecodeError representation of the various errors that might occur while decoding.
 * @since 0.9.4
 */
import { flow, pipe } from 'fp-ts/function';
import * as RA from 'fp-ts/ReadonlyArray';
import * as T from 'fp-ts/Tree';
/**
 * @category constructors
 * @since 0.9.4
 */
export const leaf = (actual, error) => ({
    _tag: 'Leaf',
    actual,
    error,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const key = (key, errors) => ({
    _tag: 'Key',
    key,
    errors,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const missingKeys = (keys) => ({
    _tag: 'MissingKeys',
    keys,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const unexpectedKeys = (keys) => ({
    _tag: 'UnexpectedKeys',
    keys,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const index = (index, errors) => ({
    _tag: 'Index',
    index,
    errors,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const missingIndexes = (indexes) => ({
    _tag: 'MissingIndexes',
    indexes,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const unexpectedIndexes = (indexes) => ({
    _tag: 'UnexpectedIndexes',
    indexes,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const member = (index, errors) => ({
    _tag: 'Member',
    index,
    errors,
});
/**
 * @category constructors
 * @since 0.9.4
 */
export const lazy = (id, errors) => ({
    _tag: 'Lazy',
    id,
    errors,
});
/**
 * @category constructors
 * @since 2.2.9
 */
export const wrap = (error, errors) => ({
    _tag: 'Wrap',
    error,
    errors,
});
/**
 * @category destructors
 * @since 0.9.4
 */
export 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;
};
/**
 * @category Typeclass Constructor
 * @since 0.9.4
 */
export function getSemigroup() {
    return RA.getSemigroup();
}
/**
 * @category Deconstructor
 * @since 0.9.4
 */
export const drawError = flow(toTree, T.drawTree);
/**
 * @category Deconstructor
 * @since 0.9.4
 */
export const drawErrors = flow(RA.map(flow(toTree, T.drawTree)), (ss) => ss.join('\n'));
function toForest(errors) {
    return errors.map(toTree);
}
function toTree(error) {
    return pipe(error, 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: pipe(keys, RA.map(T.of)) }),
        UnexpectedKeys: (keys) => ({ value: `UnexpectedKeys`, forest: pipe(keys, RA.map(T.of)) }),
        Index: (Index, errors) => ({ value: `Index ${Index}`, forest: toForest(errors) }),
        MissingIndexes: (indexes) => ({
            value: `Missing indexes`,
            forest: pipe(indexes, RA.map(flow(String, T.of))),
        }),
        UnexpectedIndexes: (indexes) => ({
            value: `Unexpected Indexes`,
            forest: pipe(indexes, RA.map(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