cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/alg/keyboard.ts

@@ -1,48 +0,0 @@
-import { Move } from "./units/leaves/Move";
-
-const cubeKeyMapping: { [key: number]: Move } = {
-  73: new Move("R"),
-  75: new Move("R'"),
-  87: new Move("B"),
-  79: new Move("B'"),
-  83: new Move("D"),
-  76: new Move("D'"),
-  68: new Move("L"),
-  69: new Move("L'"),
-  74: new Move("U"),
-  70: new Move("U'"),
-  72: new Move("F"),
-  71: new Move("F'"),
-
-  78: new Move("x'"),
-  67: new Move("l"),
-  82: new Move("l'"),
-  85: new Move("r"),
-  77: new Move("r'"),
-
-  88: new Move("d"),
-  188: new Move("d'"),
-
-  84: new Move("x"),
-  89: new Move("x"),
-  66: new Move("x'"),
-  186: new Move("y"),
-  59: new Move("y"),
-  65: new Move("y'"), // 186 is WebKit, 59 is Mozilla; see http://unixpapa.com/js/key.html
-  80: new Move("z"),
-  81: new Move("z'"),
-
-  90: new Move("M'"),
-  190: new Move("M'"),
-};
-
-// TODO: options about whether to ignore modifier keys (e.g. alt, ctrl).
-// TODO: Support different mappings.
-// TODO: Return BaseMove instead?
-export function keyToMove(e: KeyboardEvent): Move | null {
-  if (e.altKey || e.ctrlKey) {
-    return null;
-  }
-
-  return cubeKeyMapping[e.keyCode] || null;
-}

package/src/cubing/alg/limits.ts

@@ -1,4 +0,0 @@
-export const MAX_INT = 0x7fffffff; // 2^32-1, the max value for signed 32-bit ints.
-export const MAX_INT_DESCRIPTION = "2^31 - 1";
-export const MIN_INT = -0x80000000;
-export const MINT_INT_DESCRIPTION = "-2^31";

package/src/cubing/alg/operation.spec.ts

@@ -1,48 +0,0 @@
-import { Alg } from "./Alg";
-import { experimentalAppendMove } from "./operation";
-import { Move } from "./units";
-import "./test/alg-comparison";
-
-describe("operation", () => {
-  it("can append moves", () => {
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("U2")),
-    ).toBeIdentical(new Alg("R U R' U2"));
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("R", -2)),
-    ).toBeIdentical(new Alg("R U R' R2'"));
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("R")),
-    ).toBeIdentical(new Alg("R U R' R"));
-  });
-
-  it("can coalesce appended moves", () => {
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("U2"), {
-        coalesce: true,
-      }),
-    ).toBeIdentical(new Alg("R U R' U2"));
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("R", -2), {
-        coalesce: true,
-      }),
-    ).toBeIdentical(new Alg("R U R3'"));
-    expect(
-      experimentalAppendMove(new Alg("R U R'"), new Move("R"), {
-        coalesce: true,
-      }),
-    ).toBeIdentical(new Alg("R U"));
-  });
-
-  it("can concat algs", () => {
-    expect(new Alg("R U2").concat(new Alg("F' D"))).toBeIdentical(
-      new Alg("R U2 F' D"),
-    );
-    expect(
-      Array.from(new Alg("R U2").concat(new Alg("U R'")).units()).length,
-    ).toBe(4);
-    expect(new Alg("R U2").concat(new Alg("U R'"))).toBeIdentical(
-      new Alg("R U2 U R'"),
-    );
-  });
-});

package/src/cubing/alg/operation.ts

@@ -1,36 +0,0 @@
-import { Alg } from "./Alg";
-import type { Move } from "./units/leaves/Move";
-
-export function experimentalAppendMove(
-  alg: Alg,
-  newMove: Move,
-  options?: {
-    coalesce?: boolean; // defaults to false
-    mod?: number;
-  },
-): Alg {
-  const oldUnits = Array.from(alg.units());
-  const oldLastMove = oldUnits[oldUnits.length - 1] as Move | undefined;
-  if (
-    options?.coalesce &&
-    oldLastMove &&
-    oldLastMove.quantum &&
-    oldLastMove.quantum.isIdentical(newMove.quantum)
-  ) {
-    const newUnits = oldUnits.slice(0, oldUnits.length - 1);
-    let newAmount = oldLastMove.amount + newMove.amount;
-    const mod = options?.mod;
-    if (mod) {
-      newAmount = ((newAmount % mod) + mod) % mod;
-      if (newAmount * 2 > mod) {
-        newAmount -= mod;
-      }
-    }
-    if (newAmount !== 0) {
-      newUnits.push(oldLastMove.modified({ amount: newAmount }));
-    }
-    return new Alg(newUnits);
-  } else {
-    return new Alg([...oldUnits, newMove]);
-  }
-}

package/src/cubing/alg/parse.spec.ts

@@ -1,75 +0,0 @@
-import { parseAlg } from "./parse";
-import "./test/alg-comparison";
-
-describe("amount", () => {
-  it("handles 0 amounts", () => {
-    expect(parseAlg("R0").toString()).toEqual("R0");
-    // We currently allow `R0'` because some programs might need to go out of their
-    // way to avoid producing it in an edge cases. It's interpreted the same as
-    // `R0`.
-    expect(parseAlg("R0'").toString()).toEqual("R0");
-    expect(() => parseAlg("R01")).toThrow(
-      "Error at char index 1: An amount can only start with 0 if it's exactly the digit 0.",
-    );
-    expect(() => parseAlg("R00")).toThrow(
-      "Error at char index 1: An amount can only start with 0 if it's exactly the digit 0.",
-    );
-  });
-});
-
-describe("Clock", () => {
-  it("parses notation", () => {
-    expect(
-      parseAlg(
-        "  UR4+ DR4+ DL1+ UL3- U1+ R2- D5+ L6+ ALL4- y2 U3- R5- D4+ L6+  ALL5+ UL",
-      ).toString(),
-    ).toEqual(
-      "UR4+ DR4+ DL1+ UL3- U1+ R2- D5+ L6+ ALL4- y2 U3- R5- D4+ L6+ ALL5+ UL",
-    );
-    expect(parseAlg("UR_PLUS_4 D_PLUS_3' U1+").toString()).toEqual(
-      "UR4+ D3- U1+",
-    );
-    expect(() => parseAlg("UR+").toString()).toThrow(
-      "Clock dial moves must have an amount written as a natural number followed by + or -.",
-    );
-    expect(() => parseAlg("UR+2").toString()).toThrow(
-      "Clock dial moves must have an amount written as a natural number followed by + or -.",
-    );
-    expect(() => parseAlg("UR1+2").toString()).toThrow(
-      "Unexpected character at index 4. Are you missing a space?",
-    ); // TODO: Better message
-  });
-});
-
-describe("Megaminx", () => {
-  it("parses notation", () => {
-    expect(parseAlg(" R++  D-- U'  \n  R++ D++ U").toString()).toEqual(
-      "R++ D-- U'\nR++ D++ U",
-    );
-    expect(parseAlg("R_PLUSPLUS_ D_PLUSPLUS_'").toString()).toEqual("R++ D--");
-    expect(() => parseAlg("R1++").toString()).toThrow(
-      "Pochmann ++ or -- moves cannot have an amount written as a number.",
-    );
-    expect(() => parseAlg("R2++").toString()).toThrow(
-      "Pochmann ++ or -- moves cannot have an amount other than 1.",
-    );
-  });
-});
-
-describe("Square-1", () => {
-  it("parses notation", () => {
-    expect(
-      parseAlg(
-        "/ (-3,0) /  (0, 3)/ (0,-3)/ (0,3) / (2,0) / (0,2)/ (-2,0) / (4,0)  /  (0,-2) / (0, 2) / (-1,4) / (0, -3) / (0, 3)",
-      ).toString(),
-    ).toEqual(
-      "/ (-3, 0) / (0, 3) / (0, -3) / (0, 3) / (2, 0) / (0, 2) / (-2, 0) / (4, 0) / (0, -2) / (0, 2) / (-1, 4) / (0, -3) / (0, 3)",
-    );
-    expect(parseAlg("_SLASH_ (U_SQ_3' D_SQ_0) / (0, 3)").toString()).toEqual(
-      "/ (-3, 0) / (0, 3)",
-    );
-    expect(() => parseAlg("(3, 4) /(1, 2)").toString()).toThrow(
-      "Unexpected character at index 8. Are you missing a space?",
-    );
-  });
-});

package/src/cubing/alg/parse.ts

@@ -1,408 +0,0 @@
-import { Alg } from "./Alg";
-import { AlgBuilder } from "./AlgBuilder";
-import type { Unit } from "./units";
-import { Commutator } from "./units/containers/Commutator";
-import { Conjugate } from "./units/containers/Conjugate";
-import { Grouping } from "./units/containers/Grouping";
-import { LineComment } from "./units/leaves/LineComment";
-import { Move, QuantumMove } from "./units/leaves/Move";
-import { Newline } from "./units/leaves/Newline";
-import { Pause } from "./units/leaves/Pause";
-
-type StoppingChar = "," | ":" | "]" | ")";
-
-function parseIntWithEmptyFallback<T>(n: string, emptyFallback: T): number | T {
-  return n ? parseInt(n) : emptyFallback;
-}
-
-const amountRegex = /^(\d+)?('?)/;
-const moveStartRegex = /^[_\dA-Za-z]/; // TODO: Handle slash
-const quantumMoveRegex = /^((([1-9]\d*)-)?([1-9]\d*))?([_A-Za-z]+)?/;
-const commentTextRegex = /^[^\n]*/;
-const square1PairStart = /^(-?\d+), ?/; // TODO: match up with other whitespace handling?
-const square1PairEnd = /^(-?\d+)\)/; // TODO: match up with other whitespace handling?
-
-export function parseAlg(s: string): Alg {
-  return new AlgParser().parseAlg(s);
-}
-
-export function parseMove(s: string): Move {
-  return new AlgParser().parseMove(s);
-}
-
-export function parseQuantumMove(s: string): QuantumMove {
-  return new AlgParser().parseQuantumMove(s);
-}
-
-export interface ParserIndexed {
-  startCharIndex: number;
-  endCharIndex: number;
-}
-
-export type Parsed<T extends Alg | Unit> = T & ParserIndexed;
-
-// TODO: attach to parser so the end char index can default to `this.#idx`?
-function addCharIndices<T extends Alg | Unit>(
-  t: T,
-  startCharIndex: number,
-  endCharIndex: number,
-): Parsed<T> {
-  const parsedT = t as ParserIndexed & T;
-  parsedT.startCharIndex = startCharIndex;
-  parsedT.endCharIndex = endCharIndex;
-  return parsedT;
-}
-
-export function transferCharIndex<T extends Alg | Unit>(from: T, to: T): T {
-  if ("startCharIndex" in from) {
-    (to as Parsed<T>).startCharIndex = (from as Parsed<T>).startCharIndex;
-  }
-  if ("endCharIndex" in from) {
-    (to as Parsed<T>).endCharIndex = (from as Parsed<T>).endCharIndex;
-  }
-  return to;
-}
-
-type MoveSuffix = "+" | "++" | "-" | "--";
-
-// TODO: support recording string locations for moves.
-class AlgParser {
-  #input: string = "";
-  #idx: number = 0;
-
-  parseAlg(input: string): Parsed<Alg> {
-    this.#input = input;
-    this.#idx = 0;
-    const alg = this.parseAlgWithStopping([]);
-    this.mustBeAtEndOfInput();
-    return alg;
-  }
-
-  parseMove(input: string): Parsed<Move> {
-    this.#input = input;
-    this.#idx = 0;
-    const move = this.parseMoveImpl();
-    this.mustBeAtEndOfInput();
-    return move;
-  }
-
-  parseQuantumMove(input: string): QuantumMove {
-    this.#input = input;
-    this.#idx = 0;
-    const quantumMove = this.parseQuantumMoveImpl();
-    this.mustBeAtEndOfInput();
-    return quantumMove;
-  }
-
-  private mustBeAtEndOfInput() {
-    if (this.#idx !== this.#input.length) {
-      throw new Error("parsing unexpectedly ended early");
-    }
-  }
-
-  private parseAlgWithStopping(stopBefore: StoppingChar[]): Parsed<Alg> {
-    let algStartIdx = this.#idx;
-    let algEndIdx = this.#idx;
-    const algBuilder = new AlgBuilder();
-
-    // We're "crowded" if there was not a space or newline since the last unit.
-    let crowded = false;
-
-    const mustNotBeCrowded = (idx: number): void => {
-      if (crowded) {
-        throw new Error(
-          `Unexpected character at index ${idx}. Are you missing a space?`,
-        ); // TODO better error message
-      }
-    };
-
-    mainLoop: while (this.#idx < this.#input.length) {
-      const savedCharIndex = this.#idx;
-      if ((stopBefore as string[]).includes(this.#input[this.#idx])) {
-        return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
-      }
-      if (this.tryConsumeNext(" ")) {
-        crowded = false;
-        if (algBuilder.experimentalNumUnits() === 0) {
-          algStartIdx = this.#idx;
-        }
-        continue mainLoop;
-      } else if (moveStartRegex.test(this.#input[this.#idx])) {
-        mustNotBeCrowded(savedCharIndex);
-        const move = this.parseMoveImpl();
-        algBuilder.push(move);
-        crowded = true;
-        algEndIdx = this.#idx;
-        continue mainLoop;
-      } else if (this.tryConsumeNext("(")) {
-        mustNotBeCrowded(savedCharIndex);
-        const sq1PairStartMatch = this.tryRegex(square1PairStart);
-        if (sq1PairStartMatch) {
-          const topAmountString = sq1PairStartMatch[1];
-          const savedCharIndexD = this.#idx;
-          const sq1PairEndMatch = this.parseRegex(square1PairEnd);
-          const uMove = addCharIndices(
-            new Move(new QuantumMove("U_SQ_"), parseInt(topAmountString)),
-            savedCharIndex + 1,
-            savedCharIndex + 1 + topAmountString.length,
-          );
-          const dMove = addCharIndices(
-            new Move(new QuantumMove("D_SQ_"), parseInt(sq1PairEndMatch[1])),
-            savedCharIndexD,
-            this.#idx - 1,
-          );
-          const alg = addCharIndices(
-            new Alg([uMove, dMove]),
-            savedCharIndex + 1,
-            this.#idx - 1,
-          );
-          algBuilder.push(
-            addCharIndices(new Grouping(alg), savedCharIndex, this.#idx),
-          );
-          crowded = true;
-          algEndIdx = this.#idx;
-          continue mainLoop;
-        } else {
-          const alg = this.parseAlgWithStopping([")"]);
-          this.mustConsumeNext(")");
-          const amount = this.parseAmount();
-          algBuilder.push(
-            addCharIndices(
-              new Grouping(alg, amount),
-              savedCharIndex,
-              this.#idx,
-            ),
-          );
-          crowded = true;
-          algEndIdx = this.#idx;
-          continue mainLoop;
-        }
-      } else if (this.tryConsumeNext("[")) {
-        mustNotBeCrowded(savedCharIndex);
-        const A = this.parseAlgWithStopping([",", ":"]);
-        const separator = this.popNext();
-        const B = this.parseAlgWithStopping(["]"]);
-        this.mustConsumeNext("]");
-        switch (separator) {
-          case ":":
-            algBuilder.push(
-              addCharIndices(new Conjugate(A, B), savedCharIndex, this.#idx),
-            );
-            crowded = true;
-            algEndIdx = this.#idx;
-            continue mainLoop;
-          case ",":
-            algBuilder.push(
-              addCharIndices(new Commutator(A, B), savedCharIndex, this.#idx),
-            );
-            crowded = true;
-            algEndIdx = this.#idx;
-            continue mainLoop;
-          default:
-            throw "unexpected parsing error";
-        }
-      } else if (this.tryConsumeNext("\n")) {
-        algBuilder.push(
-          addCharIndices(new Newline(), savedCharIndex, this.#idx),
-        );
-        crowded = false;
-        algEndIdx = this.#idx;
-        continue mainLoop;
-      } else if (this.tryConsumeNext("/")) {
-        if (this.tryConsumeNext("/")) {
-          mustNotBeCrowded(savedCharIndex);
-          const [text] = this.parseRegex(commentTextRegex);
-          algBuilder.push(
-            addCharIndices(new LineComment(text), savedCharIndex, this.#idx),
-          );
-          crowded = false;
-          algEndIdx = this.#idx;
-          continue mainLoop;
-        } else {
-          // We allow crowding here to account for csTimer scrambles, which don't have a space between a Square-1 tuple and the following slash.
-          algBuilder.push(
-            addCharIndices(new Move("_SLASH_"), savedCharIndex, this.#idx),
-          );
-          crowded = true;
-          algEndIdx = this.#idx;
-          continue mainLoop;
-        }
-      } else if (this.tryConsumeNext(".")) {
-        mustNotBeCrowded(savedCharIndex);
-        algBuilder.push(addCharIndices(new Pause(), savedCharIndex, this.#idx));
-        crowded = true;
-        algEndIdx = this.#idx;
-        continue mainLoop;
-      } else {
-        throw new Error(`Unexpected character: ${this.popNext()}`);
-      }
-    }
-
-    if (this.#idx !== this.#input.length) {
-      throw new Error("did not finish parsing?");
-    }
-    if (stopBefore.length > 0) {
-      throw new Error("expected stopping");
-    }
-    return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
-  }
-
-  private parseQuantumMoveImpl(): QuantumMove {
-    const [, , , outerLayerStr, innerLayerStr, family] =
-      this.parseRegex(quantumMoveRegex);
-
-    return new QuantumMove(
-      family,
-      parseIntWithEmptyFallback(innerLayerStr, undefined),
-      parseIntWithEmptyFallback(outerLayerStr, undefined),
-    );
-  }
-
-  private parseMoveImpl(): Parsed<Move> {
-    const savedCharIndex = this.#idx;
-
-    if (this.tryConsumeNext("/")) {
-      return addCharIndices(new Move("_SLASH_"), savedCharIndex, this.#idx);
-    }
-
-    let quantumMove = this.parseQuantumMoveImpl();
-    // Only `hadEmptyAbsAmount` is `const`.
-    // eslint-disable-next-line prefer-const
-    let [amount, hadEmptyAbsAmount] = this.parseAmountAndTrackEmptyAbsAmount();
-    const suffix = this.parseMoveSuffix();
-
-    if (suffix) {
-      if (amount < 0) {
-        throw new Error("uh-oh");
-      }
-      if ((suffix === "++" || suffix === "--") && amount !== 1) {
-        // TODO: Handle 1 vs. null
-        throw new Error(
-          "Pochmann ++ or -- moves cannot have an amount other than 1.",
-        );
-      }
-      if ((suffix === "++" || suffix === "--") && !hadEmptyAbsAmount) {
-        throw new Error(
-          "Pochmann ++ or -- moves cannot have an amount written as a number.",
-        );
-      }
-      if ((suffix === "+" || suffix === "-") && hadEmptyAbsAmount) {
-        throw new Error(
-          "Clock dial moves must have an amount written as a natural number followed by + or -.",
-        );
-      }
-      if (suffix.startsWith("+")) {
-        quantumMove = quantumMove.modified({
-          family: `${quantumMove.family}_${
-            suffix === "+" ? "PLUS" : "PLUSPLUS"
-          }_`, // TODO
-        });
-      }
-      if (suffix.startsWith("-")) {
-        quantumMove = quantumMove.modified({
-          family: `${quantumMove.family}_${
-            suffix === "-" ? "PLUS" : "PLUSPLUS"
-          }_`, // TODO
-        });
-        amount *= -1;
-      }
-    }
-
-    const move = addCharIndices(
-      new Move(quantumMove, amount),
-      savedCharIndex,
-      this.#idx,
-    );
-    return move;
-  }
-
-  private parseMoveSuffix(): MoveSuffix | null {
-    if (this.tryConsumeNext("+")) {
-      if (this.tryConsumeNext("+")) {
-        return "++";
-      }
-      return "+";
-    }
-    if (this.tryConsumeNext("-")) {
-      if (this.tryConsumeNext("-")) {
-        return "--";
-      }
-      return "-";
-    }
-    return null;
-  }
-
-  private parseAmountAndTrackEmptyAbsAmount(): [number, boolean] {
-    const savedIdx = this.#idx;
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
-    if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(
-        `Error at char index ${savedIdx}: An amount can only start with 0 if it's exactly the digit 0.`,
-      );
-    }
-    return [
-      parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1),
-      !absAmountStr,
-    ];
-  }
-
-  private parseAmount(): number {
-    const savedIdx = this.#idx;
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
-    if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(
-        `Error at char index ${savedIdx}: An amount number can only start with 0 if it's exactly the digit 0.`,
-      );
-    }
-    return (
-      parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1)
-    );
-  }
-
-  private parseRegex(regex: RegExp): RegExpExecArray {
-    const arr = regex.exec(this.remaining());
-    if (arr === null) {
-      throw new Error("internal parsing error"); // TODO
-    }
-    this.#idx += arr[0].length;
-    return arr;
-  }
-
-  // TOD: can we avoid this?
-  private tryRegex(regex: RegExp): RegExpExecArray | null {
-    const arr = regex.exec(this.remaining());
-    if (arr === null) {
-      return null;
-    }
-    this.#idx += arr[0].length;
-    return arr;
-  }
-
-  private remaining(): string {
-    return this.#input.slice(this.#idx);
-  }
-
-  private popNext(): string {
-    const next = this.#input[this.#idx];
-    this.#idx++;
-    return next;
-  }
-
-  private tryConsumeNext(expected: string): boolean {
-    if (this.#input[this.#idx] === expected) {
-      this.#idx++;
-      return true;
-    }
-    return false;
-  }
-
-  private mustConsumeNext(expected: string): string {
-    const next = this.popNext();
-    if (next !== expected) {
-      throw new Error(
-        `expected \`${expected}\` while parsing, encountered ${next}`,
-      ); // TODO: be more helpful
-    }
-    return next;
-  }
-}

package/src/cubing/alg/test/alg-comparison.ts

@@ -1,23 +0,0 @@
-import type { Alg } from "../Alg";
-
-expect.extend({
-  toBeIdentical(expected: Alg, observed: Alg): jest.CustomMatcherResult {
-    return {
-      message: (): string => "Expected the same alg structure.",
-      pass: expected?.isIdentical(observed),
-    };
-  },
-});
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface Matchers<R, T> {
-      toBeIdentical(observed: Alg): CustomMatcherResult;
-    }
-  }
-}
-
-// This is needed to modify the global namespace.
-export {};