@logic-pad/core 0.26.2 → 0.26.3

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

@@ -0,0 +1,179 @@
+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

@@ -0,0 +1,55 @@
+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;
+}