puzzle-lib 1.3.0 → 1.6.0

package/src/Braille/BrailleStream.ts

@@ -0,0 +1,87 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {BrailleCharacter} from './BrailleCharacter';
+import {BrailleData} from './BrailleData';
+import {BrailleEncoding} from './BrailleEncoding';
+
+export class BrailleStream {
+  private readonly _chars: BrailleEncoding[] = [];
+  private _currentStr = '';
+  private _processPosition = 0;
+  private _numberMode = false;
+
+  constructor(chars?: BrailleEncoding[]) {
+    if (chars) {
+      this._chars = Array.from(chars);
+    }
+
+    this.invalidate();
+  }
+
+  get chars() {
+    return this._chars;
+  }
+
+  set chars(value: BrailleEncoding[]) {
+    this.clear();
+
+    for (const ch of value) {
+      this._chars.push(ch);
+    }
+  }
+
+  append(ch: BrailleCharacter) {
+    this._chars.push(ch.valueOf());
+  }
+
+  clear() {
+    this._chars.length = 0;
+    this.invalidate();
+  }
+
+  backspace() {
+    this._chars.pop();
+    this.invalidate();
+  }
+
+  space() {
+    this._chars.push(BrailleEncoding.None);
+  }
+
+  toString() {
+    this.update();
+    return this._currentStr;
+  }
+
+  private invalidate() {
+    this._currentStr = '';
+    this._processPosition = 0;
+    this._numberMode = false;
+  }
+
+  private update() {
+    while (this._processPosition < this._chars.length) {
+      const ch = this._chars[this._processPosition];
+
+      if (ch === BrailleEncoding.None) {
+        this._numberMode = false;
+        this._currentStr += ' ';
+      } else if (ch === BrailleEncoding.FormattingNumber) {
+        this._numberMode = true;
+        this._currentStr += '#';
+      } else {
+        const category =
+          EncodingCategory.Punctuation |
+          (this._numberMode
+            ? EncodingCategory.Number
+            : EncodingCategory.Letter);
+        const exact = BrailleData.instance.lookup(ch, category).exact;
+
+        if (exact.length > 0) {
+          this._currentStr += exact[0].toString();
+        }
+      }
+
+      this._processPosition++;
+    }
+  }
+}

package/src/Cipher/AutoKeyString.ts

@@ -0,0 +1,35 @@
+import {CaesarUtils} from './CaesarUtils';
+import {KeyedCipherStringBase} from './KeyedCipherStringBase';
+
+export class AutoKeyString extends KeyedCipherStringBase {
+  protected convert(decrypt: boolean) {
+    if (this._key.length < 1) {
+      return this._text;
+    } else {
+      const rotStr = [];
+      let keyIndex = 0;
+      let fullKey = this._key;
+
+      for (const ch of this._text) {
+        if (CaesarUtils.isAlpha(ch)) {
+          const currentLetter = CaesarUtils.rotateLetterWithKey(
+            ch,
+            fullKey,
+            keyIndex++,
+            decrypt
+          );
+          rotStr.push(currentLetter);
+          if (decrypt) {
+            fullKey += currentLetter;
+          } else {
+            fullKey += ch;
+          }
+        } else {
+          rotStr.push(ch);
+        }
+      }
+
+      return rotStr.join('');
+    }
+  }
+}

package/src/Cipher/CaesarString.ts

@@ -0,0 +1,38 @@
+import {CaesarUtils} from './CaesarUtils';
+
+export class CaesarString {
+  private _text: string;
+
+  constructor(text = '') {
+    this._text = text;
+  }
+
+  get text() {
+    return this._text;
+  }
+
+  set text(value: string) {
+    this._text = value;
+  }
+
+  getRotation(rot: number) {
+    const rotStr = [];
+
+    for (const ch of this._text) {
+      rotStr.push(CaesarUtils.rotateLetter(ch, rot));
+    }
+
+    return rotStr.join('');
+  }
+
+  getRotations() {
+    const rotations = [];
+    rotations.push(this._text);
+
+    for (let i = 1; i < 26; i++) {
+      rotations.push(this.getRotation(i));
+    }
+
+    return rotations;
+  }
+}

package/src/Cipher/CaesarUtils.ts

@@ -0,0 +1,69 @@
+import {CharacterConversion} from '../Conversion/CharacterConversion';
+
+export class CaesarUtils {
+  static rotateLetter(ch: string, rot: number) {
+    if (ch.length !== 1) {
+      throw new Error('Expected a single character');
+    }
+
+    rot %= this.alphaLength;
+    if (rot < 0) {
+      rot += this.alphaLength;
+    }
+
+    const code = ch.charCodeAt(0);
+    let base = 0;
+    if (this.isLowerAlpha(code)) {
+      base = this.lowerA;
+    } else if (this.isUpperAlpha(code)) {
+      base = this.upperA;
+    } else {
+      return ch;
+    }
+
+    return String.fromCharCode(((code - base + rot) % this.alphaLength) + base);
+  }
+
+  static rotateLetterWithKey(
+    ch: string,
+    key: string,
+    keyIndex: number,
+    decrypt = false
+  ) {
+    if (key.length === 0) {
+      return ch;
+    }
+
+    const keyCh = this.getCharacterWithMod(key, keyIndex);
+    let rot = CharacterConversion.toOrdinal(keyCh) - 1;
+
+    if (decrypt) {
+      rot = -rot;
+    }
+
+    return this.rotateLetter(ch, rot);
+  }
+
+  static isAlpha(ch: string) {
+    const code = ch.charCodeAt(0);
+    return this.isUpperAlpha(code) || this.isLowerAlpha(code);
+  }
+
+  private static upperA: number = 'A'.charCodeAt(0);
+  private static upperZ: number = 'Z'.charCodeAt(0);
+  private static lowerA: number = 'a'.charCodeAt(0);
+  private static lowerZ: number = 'z'.charCodeAt(0);
+  private static alphaLength = 26;
+
+  private static getCharacterWithMod(str: string, index: number) {
+    return str.charAt(index % str.length);
+  }
+
+  private static isUpperAlpha(code: number) {
+    return code >= this.upperA && code <= this.upperZ;
+  }
+
+  private static isLowerAlpha(code: number) {
+    return code >= this.lowerA && code <= this.lowerZ;
+  }
+}

package/src/Cipher/KeyedCipherStringBase.ts

@@ -0,0 +1,35 @@
+export abstract class KeyedCipherStringBase {
+  protected _text: string;
+  protected _key: string;
+
+  constructor(text = '', key = '') {
+    this._text = text;
+    this._key = key;
+  }
+
+  get text() {
+    return this._text;
+  }
+
+  set text(value: string) {
+    this._text = value;
+  }
+
+  get key() {
+    return this._key;
+  }
+
+  set key(value: string) {
+    this._key = value;
+  }
+
+  encrypt() {
+    return this.convert(false);
+  }
+
+  decrypt() {
+    return this.convert(true);
+  }
+
+  protected abstract convert(decrypt: boolean): string;
+}

package/src/Cipher/VigenereString.ts

@@ -0,0 +1,21 @@
+import {CaesarUtils} from './CaesarUtils';
+import {KeyedCipherStringBase} from './KeyedCipherStringBase';
+
+export class VigenereString extends KeyedCipherStringBase {
+  protected convert(decrypt: boolean) {
+    const rotStr = [];
+    let keyIndex = 0;
+
+    for (const ch of this._text) {
+      if (CaesarUtils.isAlpha(ch)) {
+        rotStr.push(
+          CaesarUtils.rotateLetterWithKey(ch, this._key, keyIndex++, decrypt)
+        );
+      } else {
+        rotStr.push(ch);
+      }
+    }
+
+    return rotStr.join('');
+  }
+}

package/src/Common/CharacterImage.ts

@@ -0,0 +1,11 @@
+import {InlineSvg} from './InlineSvg';
+
+export class CharacterImage {
+  readonly character: string;
+  readonly image: InlineSvg;
+
+  constructor(character: string, image: InlineSvg) {
+    this.character = character;
+    this.image = image;
+  }
+}

package/src/Common/EncodingCategory.ts

@@ -0,0 +1,10 @@
+export enum EncodingCategory {
+  None,
+
+  Letter = 1 << 1,
+  Number = 1 << 2,
+  Formatting = 1 << 3,
+  Punctuation = 1 << 4,
+
+  All = 0xff,
+}

package/src/Common/EncodingCharacterBase.ts

@@ -0,0 +1,72 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {EncodingEntry} from '../Common/EncodingEntry';
+import {EncodingLookupResult} from '../Common/EncodingLookupResult';
+import {EncodingDataBase} from './EncodingDataBase';
+
+export abstract class EncodingCharacterBase<T extends number> {
+  private _category: EncodingCategory;
+  private _data: EncodingDataBase<T>;
+  private _lookup: EncodingLookupResult<T> | null = null;
+
+  constructor(data: EncodingDataBase<T>, category: EncodingCategory) {
+    this._data = data;
+    this._category = category;
+    this.invalidateLookup();
+  }
+
+  get category() {
+    return this._category;
+  }
+
+  set category(value: EncodingCategory) {
+    if (this._category !== value) {
+      this._category = value;
+      this.invalidateLookup();
+    }
+  }
+
+  clear() {
+    this.onClear();
+    this.invalidateLookup();
+  }
+
+  empty() {
+    return this.onEmpty();
+  }
+
+  getExactMatches(): Array<EncodingEntry<T>> {
+    return this.ensureLookup().exact;
+  }
+
+  getPotentialMatches(): Array<EncodingEntry<T>> {
+    return this.ensureLookup().partial;
+  }
+
+  toString() {
+    return this.ensureLookup().exactString;
+  }
+
+  valid() {
+    return this.ensureLookup().exact.length > 0;
+  }
+
+  valueOf() {
+    return this.getEncoding();
+  }
+
+  protected invalidateLookup() {
+    this._lookup = null;
+  }
+
+  protected abstract onClear(): void;
+  protected abstract onEmpty(): boolean;
+  protected abstract getEncoding(): T;
+
+  private ensureLookup() {
+    if (!this._lookup) {
+      this._lookup = this._data.lookup(this.getEncoding(), this._category);
+    }
+
+    return this._lookup;
+  }
+}

package/src/Common/EncodingDataBase.ts

@@ -0,0 +1,31 @@
+import {EncodingCategory} from './EncodingCategory';
+import {EncodingEntry} from './EncodingEntry';
+import {EncodingLookupResult} from './EncodingLookupResult';
+
+export abstract class EncodingDataBase<T extends number> {
+  private readonly _entries: Array<EncodingEntry<T>> = [];
+
+  lookup(encoding: T, category: EncodingCategory = EncodingCategory.All) {
+    const result = new EncodingLookupResult<T>();
+
+    for (const entry of this._entries) {
+      if ((entry.category & category) !== 0) {
+        if (entry.encoding === encoding) {
+          result.exact.push(entry);
+        } else if ((entry.encoding & encoding) === encoding) {
+          result.partial.push(entry);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  protected addToList(
+    encoding: T,
+    category: EncodingCategory,
+    display: string
+  ) {
+    this._entries.push(new EncodingEntry<T>(encoding, category, display));
+  }
+}

package/src/Common/EncodingEntry.ts

@@ -0,0 +1,17 @@
+import {EncodingCategory} from './EncodingCategory';
+
+export class EncodingEntry<T> {
+  readonly encoding: T;
+  readonly category: EncodingCategory;
+  readonly display: string;
+
+  constructor(encoding: T, category: EncodingCategory, display: string) {
+    this.encoding = encoding;
+    this.category = category;
+    this.display = display;
+  }
+
+  toString() {
+    return this.display;
+  }
+}

package/src/Common/EncodingLookupResult.ts

@@ -0,0 +1,10 @@
+import {EncodingEntry} from './EncodingEntry';
+
+export class EncodingLookupResult<T> {
+  readonly exact: Array<EncodingEntry<T>> = [];
+  readonly partial: Array<EncodingEntry<T>> = [];
+
+  get exactString() {
+    return this.exact.map(value => value.toString()).join('/');
+  }
+}

package/src/Common/Helpers.ts

@@ -0,0 +1,13 @@
+export class Helpers {
+  static assert(condition: boolean) {
+    if (!condition) {
+      throw new Error();
+    }
+  }
+
+  static assertMsg(condition: boolean, message: string) {
+    if (!condition) {
+      throw new Error(message);
+    }
+  }
+}

package/src/Common/InlineSvg.ts

@@ -0,0 +1,15 @@
+export class InlineSvg {
+  private readonly inlineSvg: string;
+  private readonly viewBoxWidth: number;
+  private readonly viewBoxHeight: number;
+
+  constructor(inlineSvg: string, viewBoxWidth: number, viewBoxHeight: number) {
+    this.inlineSvg = inlineSvg;
+    this.viewBoxWidth = viewBoxWidth;
+    this.viewBoxHeight = viewBoxHeight;
+  }
+
+  render(): string {
+    return `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" viewBox="0 0 ${this.viewBoxWidth} ${this.viewBoxHeight}">${this.inlineSvg}</svg>`;
+  }
+}

package/src/Conversion/CharacterAutoConvert.ts

@@ -0,0 +1,108 @@
+import {CharacterEncoding} from './CharacterEncoding';
+
+export class CharacterAutoConvert {
+  // Forced encoding can be useful when converting an entire string
+  // or simply dealing with binary which has no leading zeros
+  static convertCharacter(
+    input: string,
+    forcedCharacterEncoding?: CharacterEncoding
+  ) {
+    let encoding = null;
+    if (!forcedCharacterEncoding) {
+      encoding = this.determineCharacterEncoding(input);
+    } else {
+      encoding = forcedCharacterEncoding;
+    }
+
+    if (encoding === CharacterEncoding.None) {
+      return '';
+    }
+
+    // Assume that Latin characters should remain
+    if (encoding === CharacterEncoding.Latin) {
+      return input;
+    }
+
+    const baseTen = Number.parseInt(input, 10);
+    if (encoding === CharacterEncoding.Ascii) {
+      return CharacterAutoConvert.asciiPrintable(baseTen);
+    }
+    const asciiOffset = 64;
+    if (encoding === CharacterEncoding.Ordinal) {
+      return CharacterAutoConvert.asciiPrintable(baseTen + asciiOffset);
+    }
+
+    const binary = Number.parseInt(input, 2);
+    if (
+      encoding === CharacterEncoding.FiveBitBinary &&
+      this.appearsBinary(input)
+    ) {
+      return CharacterAutoConvert.asciiPrintable(binary + asciiOffset);
+    }
+    if (
+      encoding === CharacterEncoding.EightBitBinary &&
+      this.appearsBinary(input)
+    ) {
+      return CharacterAutoConvert.asciiPrintable(binary);
+    }
+
+    if (encoding === CharacterEncoding.Ternary) {
+      const ternary = Number.parseInt(input, 3);
+      return CharacterAutoConvert.asciiPrintable(ternary + asciiOffset);
+    }
+
+    return '';
+  }
+
+  static asciiPrintable(index: number) {
+    if (index < 32 || index > 126) {
+      return '';
+    }
+    return String.fromCharCode(index);
+  }
+
+  static determineCharacterEncoding(input: string) {
+    if (input.match(/[a-z]/i)) {
+      return CharacterEncoding.Latin;
+    }
+
+    const numeric = Number.parseInt(input, 10);
+
+    if (this.appearsBinary(input)) {
+      if (input.length === 5) {
+        return CharacterEncoding.FiveBitBinary;
+      } else if (input.length === 8 || input.length === 7) {
+        return CharacterEncoding.EightBitBinary;
+      }
+    }
+
+    if (this.appearsTernary(input)) {
+      return CharacterEncoding.Ternary;
+    }
+
+    if (input.length < 3 && numeric > 0 && numeric < 27) {
+      return CharacterEncoding.Ordinal;
+    }
+
+    if (numeric > 64 && numeric < 91) {
+      return CharacterEncoding.Ascii;
+    }
+    if (numeric > 97 && numeric < 123) {
+      return CharacterEncoding.Ascii;
+    }
+
+    return CharacterEncoding.None;
+  }
+
+  private static readonly BINARY_REGEX = new RegExp('^[01]+$');
+
+  private static appearsBinary(str: string): boolean {
+    return this.BINARY_REGEX.test(str);
+  }
+
+  private static readonly TERNARY_REGEX = new RegExp('^[0-2]{3}$');
+
+  private static appearsTernary(str: string): boolean {
+    return this.TERNARY_REGEX.test(str);
+  }
+}

package/src/Conversion/CharacterConversion.ts

@@ -0,0 +1,89 @@
+import {CharacterTableEntry} from './CharacterTableEntry';
+
+export class CharacterConversion {
+  static getAsciiTable() {
+    const retVal: CharacterTableEntry[] = [];
+    CharacterConversion.addAsciiRange(
+      retVal,
+      48,
+      57,
+      CharacterConversion.toAscii,
+      127
+    );
+    CharacterConversion.addAsciiRange(
+      retVal,
+      65,
+      90,
+      CharacterConversion.toAscii,
+      127
+    );
+    CharacterConversion.addAsciiRange(
+      retVal,
+      97,
+      122,
+      CharacterConversion.toAscii,
+      127
+    );
+
+    return retVal;
+  }
+
+  static getOrdinalTable() {
+    const retVal: CharacterTableEntry[] = [];
+    CharacterConversion.addAsciiRange(
+      retVal,
+      65,
+      90,
+      CharacterConversion.toOrdinal,
+      26
+    );
+
+    return retVal;
+  }
+
+  static toAscii(ch: string) {
+    if (typeof ch !== 'string' || ch.length !== 1) {
+      throw new Error('A single character is required');
+    }
+
+    const ascii = ch.charCodeAt(0);
+    if (ascii >= 0 && ascii <= 127) {
+      return ascii;
+    }
+
+    return -1;
+  }
+
+  static toOrdinal(ch: string) {
+    if (typeof ch !== 'string' || ch.length !== 1) {
+      throw new Error('A single character is required');
+    }
+
+    const chCode = ch.charCodeAt(0);
+
+    let ordinalCode = chCode - 'a'.charCodeAt(0);
+    if (ordinalCode >= 0 && ordinalCode < 26) {
+      return ordinalCode + 1;
+    }
+
+    ordinalCode = chCode - 'A'.charCodeAt(0);
+    if (ordinalCode >= 0 && ordinalCode < 26) {
+      return ordinalCode + 1;
+    }
+
+    return -1;
+  }
+
+  private static addAsciiRange(
+    array: CharacterTableEntry[],
+    start: number,
+    end: number,
+    conversion: (value: string) => number,
+    maxValue: number
+  ) {
+    for (let i = start; i <= end; i++) {
+      const letter = String.fromCharCode(i);
+      array.push(new CharacterTableEntry(letter, conversion(letter), maxValue));
+    }
+  }
+}

package/src/Conversion/CharacterEncoding.ts

@@ -0,0 +1,9 @@
+export enum CharacterEncoding {
+  None,
+  Latin, // A = A, B = B
+  Ordinal, // A = 1, B = 2
+  FiveBitBinary, // 00001 = A, 00010 = B
+  EightBitBinary, // 01100001 = A, 01100010 = B
+  Ascii, // 65 = A, 66 = B
+  Ternary, // 001 = A, 010 = C, 200 = R
+}