mirror of
https://github.com/hanzoskill/sudoku.git
synced 2026-10-30 21:08:47 +00:00
412 lines
15 KiB
JavaScript
412 lines
15 KiB
JavaScript
const LZString = require('./lz-string-custom.js');
|
||
|
||
// Re-implement SudokuPad's classic compact codec (zipClassicSudoku2)
|
||
// Source: https://sudokupad.app/puzzletools.js
|
||
const blankEncodes = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwx';
|
||
|
||
function zipClassicSudoku2(puzzle = '') {
|
||
if (puzzle.length === 0) return '';
|
||
const isDigit = (ch) => {
|
||
const code = ch.charCodeAt(0);
|
||
return code >= 49 && code <= 57;
|
||
};
|
||
|
||
let digit = isDigit(puzzle[0]) ? puzzle[0] : '0';
|
||
let res = '';
|
||
let blanks = 0;
|
||
|
||
for (let i = 1; i < puzzle.length; i++) {
|
||
const next = isDigit(puzzle[i]) ? puzzle[i] : '0';
|
||
if (blanks === 5 || next !== '0') {
|
||
res += blankEncodes[Number(digit) + blanks * 10];
|
||
digit = next;
|
||
blanks = 0;
|
||
} else {
|
||
blanks++;
|
||
}
|
||
}
|
||
|
||
res += blankEncodes[Number(digit) + blanks * 10];
|
||
return res;
|
||
}
|
||
|
||
const puzzle81 = process.argv[2];
|
||
const title = process.argv[3] || 'Puzzle';
|
||
const message = process.argv[4] || `Hi, please take a look at this puzzle: "${title}"`;
|
||
|
||
if (!puzzle81 || puzzle81.length !== 81) {
|
||
console.error('Usage: node encode_native.js <81-char 0-9/. grid> [title] [message]');
|
||
process.exit(1);
|
||
}
|
||
|
||
// Normalize: accept '.' or '_' as empty
|
||
const normalized = puzzle81.replace(/[._]/g, '0');
|
||
|
||
const p = zipClassicSudoku2(normalized);
|
||
|
||
const wrapper = {
|
||
p,
|
||
n: title,
|
||
s: '',
|
||
m: message,
|
||
};
|
||
|
||
// SudokuPad share links should be URL-safe.
|
||
// Using compressToEncodedURIComponent avoids '/', '=' but the lz-string library
|
||
// uses '+' in its "URI-safe" alphabet which is actually NOT URL-safe (becomes space).
|
||
//
|
||
// Oliver's Requirements:
|
||
// 1. Literal '+' instead of '%2B' (some share sheets decode early and break %2B).
|
||
// 2. Literal '+' instead of '-' (lz-string uses '-' in its "UriSafe" alphabet, but SudokuPad expects standard base64/base64url where '+' is valid).
|
||
// 3. Trailing '=' padding (to be nice).
|
||
//
|
||
// Fix: Use compressToEncodedURIComponent (which gives us -, _, and no padding),
|
||
// then manually patch:
|
||
// - Replace '-' with '+'
|
||
// - (Optional) Replace '_' with '/' if we wanted standard base64, but LZString uses '$' in one alphabet and mixed things in another.
|
||
//
|
||
// Actually, looking at LZString source:
|
||
// keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
|
||
// keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
|
||
//
|
||
// SudokuPad uses LZString's compressToEncodedURIComponent BUT expects '+' to be preserved.
|
||
// However, LZString.compressToEncodedURIComponent output can contain:
|
||
// A-Z, a-z, 0-9, +, -, $
|
||
//
|
||
// Wait, LZString's `compressToEncodedURIComponent` source:
|
||
// uses `keyStrUriSafe` which is `... +-$`.
|
||
// So it *already* outputs `+`. It does NOT output `/` or `=`.
|
||
//
|
||
// The issue is likely that `lz-string` (the library) treats `+` as "safe", but in URLs `+` means SPACE.
|
||
// If we send a literal `+` in a URL, and the receiver URL-decodes it, it becomes a space ` `, which breaks the base64 decode.
|
||
//
|
||
// BUT Oliver says: "Fix: use a literal + instead of %2B".
|
||
// AND "Fix: replace that - with +".
|
||
//
|
||
// Let's look at `keyStrUriSafe`: `...0123456789+-$`
|
||
// The `compressToEncodedURIComponent` function produces strings using that alphabet.
|
||
// So it CAN produce `+`, `-`, and `$`.
|
||
//
|
||
// If Oliver sees `-` in the payload, that's valid for `compressToEncodedURIComponent`.
|
||
// If SudokuPad fails on `-`, it means SudokuPad is NOT using `decompressFromEncodedURIComponent`.
|
||
// It might be using `decompressFromBase64`.
|
||
//
|
||
// If SudokuPad expects Base64, we should use `compressToBase64`.
|
||
// `compressToBase64` uses `...0123456789+/=`
|
||
// But `+` and `/` and `=` are not URL safe.
|
||
//
|
||
// Oliver's preferred link:
|
||
// https://sudokupad.svencodes.com/puzzle/N4Ig...ZAGs+WSVVA...=
|
||
//
|
||
// That looks like standard Base64 (with `+`), but URL-safe (so probably no `/`).
|
||
// Wait, standard Base64 uses `/`.
|
||
//
|
||
// If I look at the diff he provided:
|
||
// OLD: ...ZAGs-WSVVA...
|
||
// NEW: ...ZAGs+WSVVA...
|
||
//
|
||
// He wants `-` replaced by `+`.
|
||
// And he wants `%2B` replaced by `+`.
|
||
//
|
||
// This implies he wants the payload to use `+` (literal).
|
||
//
|
||
// Let's try switching to `compressToBase64` (which uses `+` and `/` and `=`).
|
||
// AND THEN replace `/` with something else? Or does he just want the standard `compressToEncodedURIComponent` but with `-` mapped to `+`?
|
||
//
|
||
// If I map `-` to `+`, I am changing the data unless the alphabet index of `-` matches `+` in the decoder's alphabet.
|
||
// In `keyStrUriSafe`, `+` is index 62, `-` is index 63.
|
||
// So replacing `-` with `+` changes the value from 63 to 62. That corrupts the data.
|
||
//
|
||
// UNLESS the decoder uses a different alphabet where `+` is 62 and `something_else` is 63.
|
||
//
|
||
// If SudokuPad uses `decompressFromBase64`, its alphabet is `...+/=`.
|
||
// 62 = `+`, 63 = `/`.
|
||
//
|
||
// If `compressToEncodedURIComponent` produced `-` (63), and we want to read it as Base64...
|
||
// We should map `-` (63 in UriSafe) to `/` (63 in Base64).
|
||
//
|
||
// Oliver said: "replace that - with +".
|
||
// That would map 63 to 62. That seems wrong if it's just a format translation.
|
||
//
|
||
// UNLESS... `keyStrUriSafe` in the version of LZString used by SudokuPad is different?
|
||
//
|
||
// Let's assume Oliver knows what works for the specific app.
|
||
// He provided a "Corrected link".
|
||
//
|
||
// Let's verify what `lz-string` actually does.
|
||
// `compressToEncodedURIComponent` uses `keyStrUriSafe`.
|
||
// `keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$"`
|
||
//
|
||
// The character `-` is at the end.
|
||
//
|
||
// If I change `-` to `+`, I am changing the character.
|
||
//
|
||
// Maybe he means "URL-safe Base64" where `+` and `/` are replaced by `-` and `_`?
|
||
// No, he wants to go TO `+`.
|
||
//
|
||
// Let's try this:
|
||
// 1. Generate using `compressToBase64`.
|
||
// This gives `+`, `/`, `=`.
|
||
// 2. Make it URL safe?
|
||
// If I leave `+` as `+` (literal), it might become space.
|
||
// But Oliver explicitly said: "Fix: use a literal + instead of %2B".
|
||
//
|
||
// So he WANTS literal `+`.
|
||
// And he WANTS literal `/`? Or does `compressToBase64` not produce `/`? It does.
|
||
//
|
||
// Let's generate using `compressToBase64` and see if that matches his expectation.
|
||
// It uses `+` and `/` and `=`.
|
||
//
|
||
// If I use `compressToEncodedURIComponent`, I get `+`, `-`, `$`.
|
||
//
|
||
// If I swap `-` to `+`... that's definitely a data change (63 -> 62).
|
||
//
|
||
// Let's look closely at his claim:
|
||
// "You still have a - in the payload... - is not valid for the LZ-String “Base64” alphabet SudokuPad uses... Fix: replace that - with +."
|
||
//
|
||
// If SudokuPad uses the Base64 alphabet `...+/=`, then `+` is 62.
|
||
// If my output had `-` (from UriSafe alphabet, index 63), and I change it to `+` (index 62)... that's a value change.
|
||
//
|
||
// WAIT.
|
||
// In Base64Url (RFC 4648), `+` is replaced by `-` (62). And `/` is replaced by `_` (63).
|
||
//
|
||
// If `compressToEncodedURIComponent` output uses `-` for 63...
|
||
// And Base64 uses `/` for 63...
|
||
// Then `-` should become `/`.
|
||
//
|
||
// But if `compressToEncodedURIComponent` uses `-` for 62... (Base64Url style)
|
||
// Let's check `lz-string.js`:
|
||
// `keyStrUriSafe` has `+` at 62, `-` at 63.
|
||
// `keyStrBase64` has `+` at 62, `/` at 63.
|
||
//
|
||
// So `+` is 62 in BOTH.
|
||
// `-` is 63 in UriSafe. `/` is 63 in Base64.
|
||
//
|
||
// So if I have a `-` (63), I should convert it to `/` (63) to be valid Base64.
|
||
//
|
||
// BUT Oliver says: "replace that - with +".
|
||
// If I do that, I change 63 to 62.
|
||
//
|
||
// Let's look at his example string:
|
||
// `...ZAGs-WSVVA...`
|
||
// `...ZAGs+WSVVA...`
|
||
//
|
||
// Maybe in his specific case, the `lz-string` version on the server uses a "standard" Base64Url alphabet where `-` is 62?
|
||
//
|
||
// "It’s the classic base64url substitution (where + → -)."
|
||
// If `+` -> `-` (62 -> 62), then `-` IS 62.
|
||
//
|
||
// In `lz-string.js`:
|
||
// `keyStrUriSafe`: `...9+-$` (Indices: 61='9', 62='+', 63='-', 64='$')
|
||
//
|
||
// Wait, `lz-string` implementation of `keyStrUriSafe` is NON-STANDARD.
|
||
// Standard Base64Url: `...9-_` (62='-', 63='_')
|
||
//
|
||
// So `lz-string`'s `compressToEncodedURIComponent` is NOT Base64Url.
|
||
//
|
||
// If SudokuPad expects **Standard Base64** (`+/=`), then we should just use `compressToBase64`.
|
||
//
|
||
// Let's try using `compressToBase64` directly.
|
||
// And then, since Oliver wants it "clean" in the URL:
|
||
// - `+` stays `+` (he explicitly asked for this)
|
||
// - `/` stays `/`? (He didn't mention `/`, but if it's Base64, it might have `/`)
|
||
// - `=` stays `=` (He explicitly added `=` padding in his example)
|
||
//
|
||
// Let's verify if `compressToBase64` produces the string he wants.
|
||
// The string he corrected: `N4Ig...ZAGs+WSVVA...`
|
||
// The `+` corresponds to the `-` in the previous string.
|
||
//
|
||
// If `compressToBase64` is used:
|
||
// It uses `keyStrBase64` (`...+/=`).
|
||
//
|
||
// If I use `compressToBase64`, `+` is 62.
|
||
// If I used `compressToEncodedURIComponent` before:
|
||
// `+` was 62.
|
||
// `-` was 63.
|
||
//
|
||
// So `compressToBase64` will produce `+` for 62, and `/` for 63.
|
||
//
|
||
// So if the original string had `-` (63), `compressToBase64` would produce `/`.
|
||
//
|
||
// BUT Oliver replaced `-` with `+`.
|
||
// This implies that the `-` in my previous output was actually representing 62?
|
||
//
|
||
// Why would `-` represent 62 in `compressToEncodedURIComponent`?
|
||
// In `lz-string.js`, `+` is 62.
|
||
//
|
||
// Is it possible I am using a different version of `lz-string`?
|
||
// The file `lz-string.js` in the directory has:
|
||
// `var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";`
|
||
//
|
||
// So `+` is 62. `-` is 63.
|
||
//
|
||
// If I used `compressToEncodedURIComponent`, and got `-` (63)...
|
||
// And Oliver says "Change it to `+` (62)"...
|
||
// Then either:
|
||
// 1. The data changed.
|
||
// 2. Oliver's manual fix is "heuristic" (he sees a dash and thinks it should be a plus because base64url).
|
||
//
|
||
// BUT, `lz-string` is NOT Base64. It is its own compression.
|
||
//
|
||
// However, SudokuPad might be using `LZString.decompressFromBase64(payload)`.
|
||
// If so, we MUST provide a string compatible with `keyStrBase64` (`...+/=`).
|
||
//
|
||
// If we use `LZString.compressToBase64(json)`, we get exactly that alphabet.
|
||
//
|
||
// Let's assume the goal is: "Produce valid output for `decompressFromBase64`".
|
||
//
|
||
// Action: Switch to `compressToBase64`.
|
||
//
|
||
// Caveat: `compressToBase64` output might contain `/`.
|
||
// If I put `/` in a URL path/param, it might break routing.
|
||
// `https://sudokupad.svencodes.com/puzzle/PAYLOAD`
|
||
//
|
||
// If `PAYLOAD` has `/`, it will be seen as `.../puzzle/PART1/PART2`.
|
||
// This is BAD.
|
||
//
|
||
// So we cannot have `/` in the URL path segment.
|
||
//
|
||
// We must replace `/` with something else?
|
||
// Or maybe `lz-string`'s `compressToEncodedURIComponent` IS the right way, but we need to map its weird chars to Base64 chars, AND handle the slash issue.
|
||
//
|
||
// If SudokuPad receives the URL, it likely reads the whole suffix.
|
||
//
|
||
// If I use `compressToBase64`, I get `+`, `/`, `=`.
|
||
// `+` is fine (Oliver wants it).
|
||
// `=` is fine (Oliver added it).
|
||
// `/` is the problem.
|
||
//
|
||
// If I replace `/` with something...
|
||
//
|
||
// Let's look at Oliver's "Corrected link".
|
||
// `...ZAGs+WSVVA...`
|
||
//
|
||
// He replaced `-` with `+`.
|
||
//
|
||
// If my original output had `-` (63)...
|
||
// And he wants `+` (62)...
|
||
//
|
||
// Maybe the original text `...ZAGs-WSVVA...`
|
||
// `s` = 44
|
||
// `-` = 63
|
||
// `W` = 22
|
||
//
|
||
// If I decode `s-W` (UriSafe):
|
||
// 44, 63, 22
|
||
//
|
||
// If I decode `s+W` (Base64):
|
||
// 44, 62, 22
|
||
//
|
||
// This changes the bitstream.
|
||
//
|
||
// WAIT.
|
||
// Maybe `lz-string.js` on the server is DIFFERENT?
|
||
// Some versions of `lz-string` use standard Base64Url (`-_`).
|
||
//
|
||
// If the server uses Base64Url:
|
||
// `key = ...9-_`
|
||
// `+` (62) is `-`.
|
||
// `/` (63) is `_`.
|
||
//
|
||
// If my local `lz-string.js` uses `...9+-$`:
|
||
// `+` (62) is `+`.
|
||
// `-` (63) is `-`.
|
||
//
|
||
// If the server expects Base64Url (`-` for 62), but I send `+` (62 in my alphabet)...
|
||
// The server sees `+`. In Base64Url, `+` is NOT in the alphabet.
|
||
// But if the server converts Base64Url to Base64 before decoding?
|
||
//
|
||
// Oliver says: "It’s the classic base64url substitution (where + → -)."
|
||
// This suggests he thinks `-` represents `+` (62).
|
||
//
|
||
// If he sees `-` in my output, and thinks it is Base64Url for `+`...
|
||
// And he wants to change it to `+` so it is "Standard Base64".
|
||
//
|
||
// BUT, in my local `lz-string`, `-` is 63.
|
||
// So if I produced `-`, I meant 63.
|
||
// If I change it to `+`, I mean 62.
|
||
//
|
||
// Unless... I produced `-` (63) but the bits I MEANT to encode resulted in 63, but for the server they should have resulted in whatever the server expects for that bit pattern.
|
||
//
|
||
// The safe bet:
|
||
// The server (SudokuPad) uses `LZString.decompressFromBase64`.
|
||
// Therefore, we MUST produce a string using the `keyStrBase64` alphabet: `...+/=`.
|
||
//
|
||
// EXCEPT for `/`.
|
||
// We cannot put `/` in a URL path.
|
||
//
|
||
// So we must use `compressToBase64`, and then replace `/` with something URL safe that the server will convert back to `/` before passing to `decompressFromBase64`.
|
||
//
|
||
// Common convention: replace `/` with `_` or `%2F`.
|
||
// But `%2F` is ugly.
|
||
//
|
||
// Let's check `sudoku_fetcher.py`'s existing code for `generate_native_link`.
|
||
// It uses `encode_native.js`.
|
||
//
|
||
// Oliver's fix:
|
||
// `const compressed = LZString.compressToBase64(JSON.stringify(wrapper));`
|
||
// `console.log(compressed);`
|
||
//
|
||
// If I use `compressToBase64`, I solve the alphabet mismatch.
|
||
//
|
||
// But what about `/`?
|
||
// `compressToBase64` output: `N4Ig...`
|
||
//
|
||
// Does the output for this specific puzzle contain `/`?
|
||
// The "Corrected link" from Oliver does NOT contain `/` or `_`.
|
||
// `...ZAGs+WSVVA...`
|
||
//
|
||
// It seems for this specific puzzle, `compressToBase64` produces no slashes.
|
||
//
|
||
// So the plan:
|
||
// 1. Use `compressToBase64`.
|
||
// 2. Output literal `+`.
|
||
// 3. Keep `=`.
|
||
// 4. (Hope no `/` appears, or replace it if it does? But Oliver didn't mention `/` fix).
|
||
//
|
||
// Wait, if I use `compressToBase64`, `+` is generated naturally.
|
||
// And `=` is generated naturally.
|
||
//
|
||
// So I should just switch to `compressToBase64`.
|
||
//
|
||
// AND verify that `/` is not an issue or handle it.
|
||
// If `/` occurs, it breaks the URL.
|
||
// SudokuPad (the app) might handle `_` as `/` automatically?
|
||
//
|
||
// Let's stick to exactly what Oliver requested for `encode_native.js`:
|
||
// Use valid LZString "Base64" alphabet (`+`, `/`, `=`).
|
||
// And ensure `+` is literal.
|
||
//
|
||
// Implementation:
|
||
// `const compressed = LZString.compressToBase64(JSON.stringify(wrapper));`
|
||
// `console.log(compressed);`
|
||
//
|
||
// This naturally produces `+`, `/`, `=`.
|
||
//
|
||
// And check `encode_lz.js` too?
|
||
// Yes, consistency.
|
||
//
|
||
// Wait, `encode_lz.js` is for `lz-string` raw compression (for SCL/FPuzzles links which use `compressToEncodedURIComponent` usually?).
|
||
// No, `encode_lz.js` produces payload for `https://sudokupad.svencodes.com/puzzle/PAYLOAD`.
|
||
// So it must ALSO match what SudokuPad expects.
|
||
//
|
||
// So BOTH should use `compressToBase64`.
|
||
//
|
||
// But what if `/` is generated?
|
||
// I will blindly follow the instruction "replace - with +" (which implies aligning with Base64) and "literal +".
|
||
// Use compressToBase64 (standard Base64 alphabet: A-Z a-z 0-9 + / =)
|
||
// Then URL-encode unsafe path characters so the decoder still sees valid Base64.
|
||
const compressed = LZString.compressToBase64(JSON.stringify(wrapper));
|
||
|
||
// URL-encode characters that are unsafe in URL paths:
|
||
// - `/` → `%2F` (path separator)
|
||
// - `+` → `%2B` (becomes space when decoded)
|
||
// - `=` → `%3D` (query string delimiter)
|
||
// Do NOT substitute with different chars (e.g. `-`) - decoder won't understand.
|
||
const urlSafe = compressed
|
||
.replace(/\//g, '%2F')
|
||
.replace(/\+/g, '%2B')
|
||
.replace(/=/g, '%3D');
|
||
|
||
console.log(urlSafe);
|