fentastic/dist/esm/index.js

Validate and parse Forsyth-Edwards Notation (FEN) used to describe a chess game board position.

import { createTokens } from './token.js';
import { createFields, validateFields } from './createFields.js';
import { parsePieceField } from './parsePieceField.js';
import { parseActiveColor } from './parseActiveColor.js';
import { parseCastlingAvailability } from './parseCastlingAvailability.js';
import { parseEnPassantTargetSquare } from './parseEnPassantTargetSquare.js';
import { parseHalfMoveClock, parseFullMoveNumber } from './parseClocks.js';
import { ParseError, ParseErrors } from './ParseError.js';
import { validateInputFen, InputError } from './validateInputFen.js';
import { correctWhiteSpace, validateWhiteSpace } from './whiteSpaceUtils.js';
export { ParseError, InputError };
const handleErrors = (e, inputFen) => {
    if (e instanceof ParseError || e instanceof InputError) {
        return { fen: inputFen, valid: false, errors: [e] };
    }
    else if (e instanceof ParseErrors) {
        return { fen: inputFen, valid: false, errors: e.errors };
    }
    throw e;
};
export const validateFen = (inputFen) => {
    let fen;
    try {
        fen = validateInputFen(inputFen);
        const tokens = createTokens(fen);
        validateWhiteSpace(tokens);
        const fields = createFields(tokens);
        validateFields(fields);
        return { fen, valid: true };
    }
    catch (e) {
        return handleErrors(e, inputFen);
    }
};
const defaultOptions = {
    correctWhiteSpace: false
};
export const parseFen = (inputFen, options = defaultOptions) => {
    let fen;
    try {
        fen = validateInputFen(inputFen);
        let tokens = createTokens(fen);
        if (options.correctWhiteSpace) {
            tokens = correctWhiteSpace(tokens);
        }
        else {
            validateWhiteSpace(tokens);
        }
        let fields = createFields(tokens);
        fields = validateFields(fields);
        return {
            fen,
            valid: true,
            fields: fields.map((f) => f.value),
            piecePlacement: parsePieceField(fields[0]),
            activeColor: parseActiveColor(fields[1]),
            castlingAvailability: parseCastlingAvailability(fields[2]),
            enPassantTargetSquare: parseEnPassantTargetSquare(fields[3]),
            halfmoveClock: parseHalfMoveClock(fields[4]),
            fullmoveNumber: parseFullMoveNumber(fields[5])
        };
    }
    catch (e) {
        return handleErrors(e, inputFen);
    }
};