@logic-pad/core/dist/src/data/serializer/serializer_checksum.js

import { ConfigType, } from '../config.js';
import SerializerV0, { orientationChars } from './serializer_v0.js';
import { DIRECTIONS, ORIENTATIONS, } from '../primitives.js';
import { escape } from '../dataHelper.js';
import { normalizeShape, tilesToShape } from '../shapes.js';
export default class SerializerChecksum extends SerializerV0 {
    version = 4;
    parseTile(_str) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyControlLine(line) {
        const result = [];
        result.push(`c${line.column}`);
        result.push(`r${line.rows.map(row => `n${row.note ?? ''}`).join(',')}`);
        return result.join('|');
    }
    parseControlLine(_str) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyConfig(instruction, config) {
        switch (config.type) {
            case ConfigType.Boolean:
                return (config.field +
                    '=' +
                    (instruction[config.field] ? '1' : '0'));
            case ConfigType.Number:
            case ConfigType.Color:
            case ConfigType.Comparison:
            case ConfigType.Wrapping:
            case ConfigType.Direction:
            case ConfigType.Orientation:
                return (config.field +
                    '=' +
                    String(instruction[config.field])
                        .toLowerCase()
                        .trim());
            case ConfigType.NullableBoolean:
                return (config.field +
                    '=' +
                    (instruction[config.field] === null
                        ? ''
                        : instruction[config.field]
                            ? '1'
                            : '0'));
            case ConfigType.NullableNumber:
                return (config.field +
                    '=' +
                    (instruction[config.field] === null
                        ? ''
                        : String(instruction[config.field])));
            case ConfigType.DirectionToggle:
                return (config.field +
                    '=' +
                    DIRECTIONS.filter(dir => instruction[config.field][dir])
                        .map(x => orientationChars[x])
                        .join('')
                        .toLowerCase()
                        .trim());
            case ConfigType.OrientationToggle:
                return (config.field +
                    '=' +
                    ORIENTATIONS.filter(dir => instruction[config.field][dir])
                        .map(x => orientationChars[x])
                        .join('')
                        .toLowerCase()
                        .trim());
            case ConfigType.String:
            case ConfigType.Icon:
                return (config.field +
                    '=' +
                    escape(instruction[config.field]
                        .toLowerCase()
                        .trim()));
            case ConfigType.NullableNote:
                return (config.field +
                    '=' +
                    escape(instruction[config.field] === null
                        ? ''
                        : escape(String(instruction[config.field])
                            .toLowerCase()
                            .trim())));
            case ConfigType.NullableInstrument:
                return config.field + '='; // do not include instrument in checksum
            case ConfigType.Tile:
            case ConfigType.Grid:
                return (config.field +
                    '=' +
                    escape(this.stringifyGrid(instruction[config.field])));
            case ConfigType.Shape:
                return (config.field +
                    '=' +
                    escape(normalizeShape(tilesToShape(instruction[config.field].tiles))
                        .elements.map(elm => `${elm.x}-${elm.y}-${elm.color}`)
                        .sort()
                        .join('/')));
            case ConfigType.NullableGrid:
                return (config.field +
                    '=' +
                    escape(instruction[config.field] === null
                        ? ''
                        : this.stringifyGrid(instruction[config.field])));
            case ConfigType.ControlLines:
                return (config.field +
                    '=' +
                    escape(instruction[config.field]
                        .map(line => this.stringifyControlLine(line))
                        .join(':')));
            case ConfigType.SolvePath:
                return (config.field +
                    '=' +
                    escape(instruction[config.field]
                        ?.map(pos => `${pos.x}_${pos.y}`)
                        .join('/') ?? ''));
        }
    }
    parseConfig(_configs, _entry) {
        throw new Error('Checksum serializer does not support parsing');
    }
    parseRule(_str) {
        throw new Error('Checksum serializer does not support parsing');
    }
    parseSymbol(_str) {
        throw new Error('Checksum serializer does not support parsing');
    }
    parseConnections(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyZones(zones) {
        return `Z${zones.edges
            .map(edge => `${edge.x1}_${edge.y1}_${edge.x2 - edge.x1}_${edge.y2 - edge.y1}`)
            .sort()
            .join(':')}`;
    }
    parseZones(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    parseTiles(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyRules(rules) {
        return `R${rules
            .filter(rule => rule.necessaryForCompletion)
            .map(rule => this.stringifyRule(rule))
            .sort()
            .join(':')}`;
    }
    parseRules(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifySymbols(symbols) {
        return `S${Array.from(symbols.values())
            .flat()
            .filter(symbol => symbol.necessaryForCompletion)
            .map(symbol => this.stringifySymbol(symbol))
            .sort()
            .join(':')}`;
    }
    parseSymbols(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyGrid(grid) {
        return super.stringifyGrid(grid.resetTiles());
    }
    parseGrid(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyGridWithSolution(puzzle) {
        return this.stringifyGrid(puzzle.grid);
    }
    parseGridWithSolution(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
    stringifyPuzzle(puzzle) {
        return this.stringifyGrid(puzzle.grid);
    }
    parsePuzzle(_input) {
        throw new Error('Checksum serializer does not support parsing');
    }
}