cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/alg/example.ts

@@ -1,152 +0,0 @@
-// tslint:disable-next-line no-namespace // TODO: nested module
-
-import { Alg } from "./Alg";
-import { Grouping } from "./units";
-import { Commutator } from "./units/containers/Commutator";
-import { Conjugate } from "./units/containers/Conjugate";
-import { Move } from "./units/leaves/Move";
-import { Pause } from "./units/leaves/Pause";
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export const Example = {
-  Sune: new Alg([
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", 1),
-    new Move("R", 1),
-    new Move("U", -2),
-    new Move("R", -1),
-  ]),
-
-  AntiSune: new Alg([
-    new Move("R", 1),
-    new Move("U", 2),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("R", -1),
-  ]),
-
-  SuneCommutator: new Alg([
-    new Commutator(
-      new Alg([new Move("R", 1), new Move("U", 1), new Move("R", -2)]),
-      new Alg([
-        new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)])),
-      ]),
-    ),
-  ]),
-
-  Niklas: new Alg([
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("L", -1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("L", 1),
-    new Move("U", 1),
-  ]),
-
-  EPerm: new Alg([
-    new Move("x", -1),
-    new Commutator(
-      new Alg([
-        new Conjugate(
-          new Alg([new Move("R", 1)]),
-          new Alg([new Move("U", -1)]),
-        ),
-      ]),
-      new Alg([new Move("D", 1)]),
-    ),
-    new Commutator(
-      new Alg([
-        new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)])),
-      ]),
-      new Alg([new Move("D", 1)]),
-    ),
-    new Move("x", 1),
-  ]),
-
-  FURURFCompact: new Alg([
-    new Conjugate(
-      new Alg([new Move("F", 1)]),
-      new Alg([
-        new Commutator(
-          new Alg([new Move("U", 1)]),
-          new Alg([new Move("R", 1)]),
-        ),
-      ]),
-    ),
-  ]),
-
-  APermCompact: new Alg([
-    new Conjugate(
-      new Alg([new Move("R", 2)]),
-      new Alg([
-        new Commutator(
-          new Alg([new Move("F", 2)]),
-          new Alg([new Move("R", -1), new Move("B", -1), new Move("R", 1)]),
-        ),
-      ]),
-    ),
-  ]),
-
-  FURURFMoves: new Alg([
-    new Move("F", 1),
-    new Move("U", 1),
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("F", -1),
-  ]),
-
-  TPerm: new Alg([
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("F", 1),
-    new Move("R", 2),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("F", -1),
-  ]),
-
-  HeadlightSwaps: new Alg([
-    new Conjugate(
-      new Alg([new Move("F", 1)]),
-      new Alg([
-        new Grouping(
-          new Alg([
-            new Commutator(
-              new Alg([new Move("R", 1)]),
-              new Alg([new Move("U", 1)]),
-            ),
-          ]),
-          3,
-        ),
-      ]),
-    ),
-  ]),
-
-  TriplePause: new Alg([new Pause(), new Pause(), new Pause()]),
-
-  // AllAlgParts: [
-  //   new Alg([new Move("R", 1), new Move("U", -1)]),
-  //   new Grouping(new Alg([new Move("F", 1)]), 2),
-  //   // new Rotation("y", -1),
-  //   new Move("R", 2),
-  //   new Commutator(new Alg([new Move("R", 2)]), new Alg([new Move("U", 2)]), 2),
-  //   new Conjugate(new Alg([new Move("L", 2)]), new Alg([new Move("D", -1)]), 2),
-  //   new Pause(),
-  //   new Newline(),
-  //   new LineComment("line comment"),
-  // ],
-};

package/src/cubing/alg/index.ts

@@ -1,21 +0,0 @@
-export { Alg } from "./Alg";
-export { AlgBuilder } from "./AlgBuilder";
-export { TraversalDownUp, TraversalUp } from "./traversal";
-export { Example } from "./example";
-export { keyToMove } from "./keyboard";
-export * from "./units";
-export { MoveModifications } from "./units/leaves/Move";
-
-export { algCubingNetLink } from "./url";
-export type { AlgCubingNetOptions } from "./url";
-
-export { experimentalAppendMove } from "./operation";
-export { experimentalIs } from "./is";
-export {
-  directedGenerator as experimentalDirectedGenerator,
-  direct as experimentalDirect,
-  IterationDirection as ExperimentalIterationDirection,
-} from "./iteration";
-
-// TODO: Find a better way to track parsed algs.
-export type { Parsed as ExperimentalParsed } from "./parse";

package/src/cubing/alg/is.ts

@@ -1,38 +0,0 @@
-import type { Alg } from "./Alg";
-import {
-  Commutator,
-  Conjugate,
-  Grouping,
-  LineComment,
-  Move,
-  Newline,
-  Pause,
-} from "./units";
-
-export function experimentalIs(
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  v: any,
-  c:
-    | typeof Alg
-    | typeof Grouping
-    | typeof LineComment
-    | typeof Commutator
-    | typeof Conjugate
-    | typeof Move
-    | typeof Newline
-    | typeof Pause,
-): boolean {
-  return v instanceof c;
-}
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function experimentalIsUnit(v: any): boolean {
-  return (
-    experimentalIs(v, Grouping) ||
-    experimentalIs(v, LineComment) ||
-    experimentalIs(v, Commutator) ||
-    experimentalIs(v, Conjugate) ||
-    experimentalIs(v, Move) ||
-    experimentalIs(v, Newline) ||
-    experimentalIs(v, Pause)
-  );
-}

package/src/cubing/alg/iteration.ts

@@ -1,45 +0,0 @@
-export enum IterationDirection {
-  Forwards = 1,
-  Backwards = -1,
-}
-
-export function toggleDirection(
-  iterationDirection: IterationDirection,
-  flip: boolean = true,
-): IterationDirection {
-  if (!flip) {
-    return iterationDirection;
-  }
-  switch (iterationDirection) {
-    case IterationDirection.Forwards:
-      return IterationDirection.Backwards;
-    case IterationDirection.Backwards:
-      return IterationDirection.Forwards;
-  }
-}
-
-export function direct<T>(
-  g: Iterable<T>,
-  iterDir: IterationDirection,
-): Iterable<T> {
-  return iterDir === IterationDirection.Backwards ? Array.from(g).reverse() : g;
-}
-
-export function reverse<T>(g: Iterable<T>): Iterable<T> {
-  return Array.from(g).reverse();
-}
-
-export function* directedGenerator<T>(
-  g: Generator<T>,
-  direction: IterationDirection,
-): Generator<T> {
-  direction === IterationDirection.Backwards
-    ? yield* reverseGenerator(g)
-    : yield* g;
-}
-
-export function* reverseGenerator<T>(g: Generator<T>): Generator<T> {
-  for (const t of Array.from(g).reverse()) {
-    yield t;
-  }
-}

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?",
-    );
-  });
-});