@logic-pad/core 0.26.0 → 0.26.2

package/dist/src/data/serializer/serializer_checksum.js

@@ -1,179 +0,0 @@
-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');
-    }
-}

package/dist/src/data/serializer/serializer_v0.d.ts

@@ -1,55 +0,0 @@
-import GridData from '../grid.js';
-import GridConnections from '../gridConnections.js';
-import Rule from '../rules/rule.js';
-import TileData from '../tile.js';
-import Symbol from '../symbols/symbol.js';
-import Instruction from '../instruction.js';
-import { AnyConfig } from '../config.js';
-import SerializerBase from './serializerBase.js';
-import { Puzzle, PuzzleData } from '../puzzle.js';
-import { ControlLine } from '../rules/musicControlLine.js';
-import GridZones from '../gridZones.js';
-export declare const OFFSETS: {
-    x: number;
-    y: number;
-}[];
-export declare const orientationChars: {
-    up: string;
-    "up-right": string;
-    right: string;
-    "down-right": string;
-    down: string;
-    "down-left": string;
-    left: string;
-    "up-left": string;
-};
-export default class SerializerV0 extends SerializerBase {
-    readonly version: number;
-    stringifyTile(tile: TileData): string;
-    parseTile(str: string): TileData;
-    stringifyControlLine(line: ControlLine): string;
-    parseControlLine(str: string): ControlLine;
-    stringifyConfig(instruction: Instruction, config: AnyConfig): string;
-    parseConfig(configs: readonly AnyConfig[], entry: string): [string, unknown];
-    stringifyInstruction(instruction: Instruction): string;
-    stringifyRule(rule: Rule): string;
-    stringifySymbol(symbol: Symbol): string;
-    parseRule(str: string): Rule;
-    parseSymbol(str: string): Symbol;
-    stringifyConnections(connections: GridConnections): string;
-    parseConnections(input: string): GridConnections;
-    stringifyZones(zones: GridZones): string;
-    parseZones(input: string): GridZones;
-    stringifyTiles(tiles: readonly (readonly TileData[])[]): string;
-    parseTiles(input: string): TileData[][];
-    stringifyRules(rules: readonly Rule[]): string;
-    parseRules(input: string): Rule[];
-    stringifySymbols(symbols: ReadonlyMap<string, readonly Symbol[]>): string;
-    parseSymbols(input: string): Map<string, Symbol[]>;
-    stringifyGrid(grid: GridData): string;
-    parseGrid(input: string): GridData;
-    stringifyGridWithSolution(puzzle: PuzzleData): string;
-    parseGridWithSolution(input: string): PuzzleData;
-    stringifyPuzzle(puzzle: Puzzle): string;
-    parsePuzzle(input: string): Puzzle;
-}