cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/puzzles/stickerings/global-custom-stickering-hack.ts

@@ -1,61 +0,0 @@
-import type { TwistyPlayer } from "../../twisty";
-import {
-  PieceStickering,
-  PuzzleStickering,
-  StickeringManager,
-} from "./appearance";
-
-type Stickerer = (
-  puzzleStickering: PuzzleStickering,
-  m: StickeringManager,
-) => void;
-
-let globalCustomStickerer: Stickerer = () => {};
-
-function setGlobalCustomStickerer(stickerer: Stickerer): void {
-  (async () => {
-    globalCustomStickerer = stickerer;
-
-    const players: TwistyPlayer[] = Array.from(
-      document.body.querySelectorAll("twisty-player"),
-    );
-    console.log(`Setting the custom stickering for ${players.length} players!`);
-    const successPromises = [];
-    for (const player of players) {
-      successPromises.push(
-        (async () => {
-          const stickering =
-            await player.experimentalModel.stickeringProp.get();
-          player.experimentalStickering =
-            stickering === "experimental-global-custom-1"
-              ? "experimental-global-custom-2"
-              : "experimental-global-custom-1";
-        })(),
-      );
-    }
-    await Promise.all(successPromises);
-    console.log("Success!");
-  })();
-}
-
-export function useGlobalCustomStickerer(
-  puzzleStickering: PuzzleStickering,
-  m: StickeringManager,
-): void {
-  globalCustomStickerer(puzzleStickering, m);
-}
-
-if (
-  globalThis.location &&
-  new URL(location.href).searchParams.get("global-custom-stickerer") === "true"
-) {
-  (window as any).setGlobalCustomStickerer = setGlobalCustomStickerer;
-  (window as any).PieceStickering = PieceStickering;
-  console.log(
-    "Global custom stickerer enabled! (using: global-custom-stickerer=true)",
-  );
-  console.log(
-    "Look here for inspiration:",
-    "https://github.com/cubing/cubing.js/blob/81b5cab3e27d8defb39dd1e0a10bc9e8ba894d26/src/cubing/puzzles/stickerings/cube-stickerings.ts#L67",
-  );
-}

package/src/cubing/puzzles/stickerings/megaminx-stickerings.ts

@@ -1,26 +0,0 @@
-import type { ExperimentalStickering } from "../../twisty";
-import type { PuzzleLoader } from "../PuzzleLoader";
-import type { PuzzleAppearance } from "./appearance";
-import { cubeAppearance } from "./cube-stickerings";
-
-// TODO: cache calculations?
-export async function megaminxAppearance(
-  puzzleLoader: PuzzleLoader,
-  stickering: ExperimentalStickering,
-): Promise<PuzzleAppearance> {
-  switch (stickering) {
-    case "full":
-    case "F2L":
-    case "LL":
-      return cubeAppearance(puzzleLoader, stickering);
-    default:
-      console.warn(
-        `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`,
-      );
-  }
-  return cubeAppearance(puzzleLoader, "full");
-}
-
-export async function megaminxStickerings(): Promise<ExperimentalStickering[]> {
-  return ["full", "F2L", "LL"];
-}

package/src/cubing/scramble/index.ts

@@ -1 +0,0 @@
-export { experimentalRandomScrambleForEvent as randomScrambleForEvent } from "../search";

package/src/cubing/search/.gitignore

@@ -1 +0,0 @@
-/worker-inside-generated*

package/src/cubing/search/esm-test-worker.js

@@ -1,14 +0,0 @@
-// We need to use a static `import` statement instead of dynamic `import()` to
-// test true compatibility (Snowpack behaves differently for those two, for
-// example). This may result in an unpreventable extra error in the console.
-import { expose } from "../vendor/comlink-everywhere/inside";
-
-export const esmTestAPIImplementation = {
-  test: (s) => {
-    if (s === "to worker") {
-      return "from worker";
-    }
-  },
-};
-
-expose(esmTestAPIImplementation);

package/src/cubing/search/index.ts

@@ -1,12 +0,0 @@
-export {
-  randomScrambleForEvent as experimentalRandomScrambleForEvent,
-  experimentalSolve3x3x3IgnoringCenters,
-  experimentalSolve2x2x2,
-  solveSkewb,
-  solvePyraminx,
-  solveMegaminx,
-  setDebug,
-} from "./outside";
-
-// TODO: handle centers properly.
-export { random333State } from "./inside/solve/puzzles/3x3x3";

package/src/cubing/search/inside/api.spec.ts

@@ -1,37 +0,0 @@
-import { insideAPI, setDebugMeasurePerf } from "./api";
-
-const events = [
-  "333",
-  "222",
-  "444",
-  "555",
-  "666",
-  "777",
-  "333bf",
-  "333fm",
-  "333oh",
-  // "clock",
-  // "minx",
-  "pyram",
-  "skewb",
-  "sq1",
-  "444bf",
-  "555bf",
-  "333mb",
-];
-
-setDebugMeasurePerf(false);
-
-describe("Internal API", () => {
-  for (const event of events) {
-    it(`Generates scramble alg for event: ${event}`, () => {
-      expect(() => insideAPI.randomScrambleForEvent(event)).not.toThrow();
-    });
-  }
-
-  for (const event of events) {
-    it(`Generates scramble string for event: ${event}`, () => {
-      expect(() => insideAPI.randomScrambleStringForEvent(event)).not.toThrow();
-    });
-  }
-});

package/src/cubing/search/inside/api.ts

@@ -1,174 +0,0 @@
-import type { Alg } from "../../alg";
-import {
-  preInitialize222,
-  random222Scramble,
-  solve222,
-} from "./solve/puzzles/2x2x2";
-import {
-  initialize333,
-  random333FewestMovesScramble,
-  random333OrientedScramble,
-  random333Scramble,
-  solve333,
-} from "./solve/puzzles/3x3x3";
-import {
-  initialize444,
-  random444OrientedScramble,
-  random444Scramble,
-} from "./solve/puzzles/4x4x4";
-import { solveMegaminx } from "./solve/puzzles/megaminx";
-import {
-  randomPyraminxScrambleFixedOrientation,
-  solvePyraminx,
-} from "./solve/puzzles/pyraminx";
-import {
-  randomSkewbFixedCornerScramble,
-  solveSkewb,
-} from "./solve/puzzles/skewb";
-import { setIsInsideWorker } from "./inside-worker";
-import { bigCubeRandomMoves } from "./solve/puzzles/big-cubes";
-import { oriented555RandomMoves } from "./solve/puzzles/5x5x5";
-import { getRandomSquare1Scramble } from "./solve/puzzles/sq1";
-import type { Transformation } from "../../kpuzzle";
-import { randomFTOScramble } from "./solve/puzzles/fto";
-
-setIsInsideWorker(true);
-
-let DEBUG_MEASURE_PERF = true;
-export function setDebugMeasurePerf(newDebugMeasurePerf: boolean): void {
-  DEBUG_MEASURE_PERF = newDebugMeasurePerf;
-}
-
-function now() {
-  return (typeof performance === "undefined" ? Date : performance).now();
-}
-
-async function measurePerf<T>(
-  name: string,
-  f: () => T | Promise<T>,
-): Promise<T> {
-  if (!DEBUG_MEASURE_PERF) {
-    return f();
-  }
-
-  const start = now();
-  const result = f();
-  if ((result as any)?.then) {
-    await result;
-  }
-  const end = now();
-  console.warn(`${name}: ${Math.round(end - start)}ms`);
-  return result;
-}
-
-export const insideAPI = {
-  initialize: async (eventID: string) => {
-    switch (eventID) {
-      case "222":
-        return measurePerf("preInitialize222", preInitialize222);
-      case "333":
-      case "333oh":
-      case "333ft":
-        return measurePerf("initialize333", initialize333);
-      case "444":
-        return measurePerf("initialize444", initialize444);
-      default:
-        throw new Error(`unsupported event: ${eventID}`);
-    }
-  },
-
-  randomScrambleForEvent: async (eventID: string): Promise<Alg> => {
-    switch (eventID) {
-      case "222":
-        return measurePerf("random222Scramble", random222Scramble);
-      case "333":
-      case "333oh":
-      case "333ft":
-        return measurePerf("random333Scramble", random333Scramble);
-      case "333fm":
-        return measurePerf(
-          "random333FewestMovesScramble",
-          random333FewestMovesScramble,
-        );
-      case "333bf":
-      case "333mb":
-        return measurePerf(
-          "random333OrientedScramble",
-          random333OrientedScramble,
-        );
-      case "444":
-        return measurePerf("random444Scramble", random444Scramble);
-      case "444bf":
-        return measurePerf(
-          "random444OrientedScramble",
-          random444OrientedScramble,
-        );
-      case "555":
-        return measurePerf(
-          "bigCubeScramble(5)",
-          bigCubeRandomMoves.bind(bigCubeRandomMoves, 5),
-        );
-      case "555bf":
-        return measurePerf("oriented555RandomMoves", oriented555RandomMoves);
-      case "666":
-        return measurePerf(
-          "bigCubeScramble(6)",
-          bigCubeRandomMoves.bind(bigCubeRandomMoves, 6),
-        );
-      case "777":
-        return measurePerf(
-          "bigCubeScramble(7)",
-          bigCubeRandomMoves.bind(bigCubeRandomMoves, 7),
-        );
-      case "skewb":
-        return measurePerf(
-          "randomSkewbFixedCornerScramble",
-          randomSkewbFixedCornerScramble,
-        );
-      case "pyram":
-        return measurePerf(
-          "randomPyraminxScrambleFixedOrientation",
-          randomPyraminxScrambleFixedOrientation,
-        );
-      case "sq1":
-        return measurePerf(
-          "getRandomSquare1Scramble",
-          getRandomSquare1Scramble,
-        );
-      case "fto":
-        return measurePerf("randomFTOScramble", randomFTOScramble);
-      default:
-        throw new Error(`unsupported event: ${eventID}`);
-    }
-  },
-
-  randomScrambleStringForEvent: async (eventID: string): Promise<string> => {
-    return (await insideAPI.randomScrambleForEvent(eventID)).toString();
-  },
-
-  solve333ToString: async (s: Transformation): Promise<string> => {
-    return (await solve333(s)).toString();
-  },
-
-  solve222ToString: async (s: Transformation): Promise<string> => {
-    return (await solve222(s)).toString();
-  },
-
-  solveSkewbToString: async (s: Transformation): Promise<string> => {
-    return (await solveSkewb(s)).toString();
-  },
-
-  solvePyraminxToString: async (s: Transformation): Promise<string> => {
-    return (await solvePyraminx(s)).toString();
-  },
-
-  solveMegaminxToString: async (s: Transformation): Promise<string> => {
-    return (await solveMegaminx(s)).toString();
-  },
-
-  setDebugMeasurePerf: async (measure: boolean): Promise<void> => {
-    setDebugMeasurePerf(measure);
-  },
-};
-
-export type WorkerInsideAPI = typeof insideAPI;

package/src/cubing/search/inside/entry.js

@@ -1,4 +0,0 @@
-import { expose } from "../../vendor/comlink-everywhere/inside";
-import { insideAPI } from "./api";
-
-expose(insideAPI);

package/src/cubing/search/inside/inside-worker.ts

@@ -1,13 +0,0 @@
-let isInsideWorker = false;
-
-export function setIsInsideWorker(inside: boolean) {
-  isInsideWorker = inside;
-}
-
-export function mustBeInsideWorker(): void {
-  if (!isInsideWorker) {
-    throw new Error(
-      "Must be called from inside a worker, to avoid impact on page performance. Try importing from the top level of `cubing/solve`?",
-    );
-  }
-}

package/src/cubing/search/inside/module-entry-path-getter.ts

@@ -1,5 +0,0 @@
-(globalThis as any).DO_NOT_EXPOSE_API = true;
-
-export async function getWorkerEntryFileURL() {
-  return (await import("./module-entry")).WORKER_ENTRY_FILE_URL
-}

package/src/cubing/search/inside/module-entry.ts

@@ -1,20 +0,0 @@
-// TODO: can we avoid this?
-async function getNodeMessagePort() {
-  return (
-    await import("../../vendor/comlink-everywhere/inside/node.js")
-  ).port();
-}
-
-if (!(globalThis as any).DO_NOT_EXPOSE_API) {
-  (async () => {
-    await import("./entry.js");
-
-    // // Workaround for `node`
-    const messagePort = (globalThis as any).postMessage
-      ? globalThis
-      : await getNodeMessagePort();
-    messagePort.postMessage("comlink-exposed");
-  })();
-}
-
-export const WORKER_ENTRY_FILE_URL = import.meta.url;

package/src/cubing/search/inside/solve/addOrientationSuffix.ts

@@ -1,17 +0,0 @@
-import { Alg, AlgBuilder, Move } from "../../../alg";
-import { randomChoiceFactory } from "../../../vendor/random-uint-below";
-
-export async function addOrientationSuffix(
-  alg: Alg,
-  suffixSpec: (null | string)[][],
-): Promise<Alg> {
-  const algBuilder = new AlgBuilder();
-  algBuilder.experimentalPushAlg(alg);
-  for (const suffix of suffixSpec) {
-    const choice = ((await randomChoiceFactory()) as any)(suffix);
-    if (choice !== null) {
-      algBuilder.push(Move.fromString(choice));
-    }
-  }
-  return algBuilder.toAlg();
-}

package/src/cubing/search/inside/solve/parseSGS.ts

@@ -1,119 +0,0 @@
-import { Alg } from "../../../alg";
-import {
-  identityTransformation,
-  invertTransformation,
-  KPuzzle,
-  KPuzzleDefinition,
-  Transformation,
-} from "../../../kpuzzle";
-
-interface PieceReference {
-  orbitName: string;
-  permutationIdx: number;
-}
-
-export interface SGSAction {
-  alg: Alg;
-  transformation: Transformation;
-}
-
-export interface SGSCachedData {
-  ordering: {
-    pieceOrdering: PieceReference[];
-    lookup: Record<string, SGSAction>;
-  }[];
-}
-
-export function parseSGS(def: KPuzzleDefinition, sgs: string): SGSCachedData {
-  const subgroupSizes: number[] = [];
-  const sgsActions: SGSAction[] = [];
-  for (const line of sgs.split("\n")) {
-    const lineTokens = line.split(" ");
-    if (line.startsWith("SetOrder ")) {
-      // ignore
-    } else if (line.startsWith("Alg ")) {
-      const alg = Alg.fromString(line.substring(4));
-      const kpuzzle = new KPuzzle(def);
-      kpuzzle.reset();
-      kpuzzle.applyAlg(alg);
-      sgsActions.push({ alg: alg, transformation: kpuzzle.state });
-    } else if (line.startsWith("SubgroupSizes ")) {
-      for (let j = 1; j < lineTokens.length; j++) {
-        subgroupSizes.push(parseInt(lineTokens[j]));
-      }
-    }
-  }
-
-  const sgsCachedData: SGSCachedData = {
-    ordering: new Array(subgroupSizes.length),
-  };
-  const subgroupAlgOffsets: number[] = [];
-  let sum = 0;
-  subgroupAlgOffsets.push(0);
-  const emptyAlg = Alg.fromString("");
-  const identity = identityTransformation(def);
-  for (let i = 0; i < subgroupSizes.length; i++) {
-    sum += subgroupSizes[i];
-    subgroupAlgOffsets.push(sum);
-    sgsActions.splice(sum - 1, 0, { alg: emptyAlg, transformation: identity });
-  }
-  if (sgsActions.length !== sum) {
-    throw Error(
-      `Bad sgs; expected ${sum - subgroupSizes.length} algs but saw ${
-        sgsActions.length - subgroupSizes.length
-      }`,
-    );
-  }
-  const processedPieces: Record<string, boolean[]> = {};
-  for (const orbitName in def.orbits) {
-    const orbitDefinition = def.orbits[orbitName];
-    processedPieces[orbitName] = new Array(orbitDefinition.numPieces).fill(
-      false,
-    );
-  }
-  for (let i = subgroupSizes.length - 1; i >= 0; i--) {
-    const pieceOrdering: PieceReference[] = [];
-    for (let j = subgroupAlgOffsets[i]; j < subgroupAlgOffsets[i + 1]; j++) {
-      const transformation = sgsActions[j].transformation;
-      for (const orbitName in def.orbits) {
-        const orbitDefinition = def.orbits[orbitName];
-        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
-          if (
-            transformation[orbitName].permutation[idx] !== idx ||
-            transformation[orbitName].orientation[idx] !== 0
-          ) {
-            if (!processedPieces[orbitName][idx]) {
-              pieceOrdering.push({ orbitName: orbitName, permutationIdx: idx });
-              processedPieces[orbitName][idx] = true;
-            }
-          }
-        }
-      }
-    }
-    const lookup: Record<string, SGSAction> = {};
-    for (let j = subgroupAlgOffsets[i]; j < subgroupAlgOffsets[i + 1]; j++) {
-      const transformation = invertTransformation(
-        def,
-        sgsActions[j].transformation,
-      );
-      let key = "";
-      for (let k = 0; k < pieceOrdering.length; k++) {
-        const loc = pieceOrdering[k];
-        key = `${key} ${
-          transformation[loc.orbitName].permutation[loc.permutationIdx]
-        } ${transformation[loc.orbitName].orientation[loc.permutationIdx]}`;
-      }
-      lookup[key] = sgsActions[j];
-      sgsActions[j].alg = sgsActions[j].alg.invert();
-      sgsActions[j].transformation = invertTransformation(
-        def,
-        sgsActions[j].transformation,
-      );
-    }
-    sgsCachedData.ordering[i] = {
-      pieceOrdering: pieceOrdering,
-      lookup: lookup,
-    };
-  }
-  return sgsCachedData;
-}

package/src/cubing/search/inside/solve/puzzles/2x2x2.sgs.json.ts

@@ -1,114 +0,0 @@
-import { cube2x2x2 } from "../../../../puzzles";
-import { parseSGS, SGSCachedData } from "../parseSGS";
-
-let cachedData: Promise<SGSCachedData> | null = null;
-export async function cachedData222() {
-  return (cachedData ??= data222());
-}
-
-// TODO: Reduce info.
-export async function data222(): Promise<SGSCachedData> {
-  return parseSGS(
-    await cube2x2x2.def(),
-    `SubgroupSizes 24 21 18 15 12 9 6
-
-Alg F
-Alg F2
-Alg F'
-Alg D
-Alg D2
-Alg D'
-Alg L
-Alg L2
-Alg L'
-Alg F U
-Alg F U2
-Alg F U'
-Alg F L
-Alg F L2
-Alg F L'
-Alg F2 U
-Alg F2 U'
-Alg F2 R
-Alg F2 R'
-Alg F' D
-Alg F' D'
-Alg F' R
-Alg F' R'
-Alg B
-Alg B2
-Alg B'
-Alg B R
-Alg B R2
-Alg B R'
-Alg B2 U
-Alg B2 U2
-Alg B2 U'
-Alg B2 R
-Alg B2 R2
-Alg B2 R'
-Alg B' U
-Alg B' U'
-Alg F D' F'
-Alg F2 L F2
-Alg B R' B2
-Alg B R' U2
-Alg B2 U R'
-Alg B2 R B'
-Alg R
-Alg R2
-Alg R'
-Alg R2 U
-Alg R2 U2
-Alg R2 U'
-Alg R' U
-Alg R' U2
-Alg R' U'
-Alg F R F'
-Alg F R2 F'
-Alg L2 D' L2
-Alg L' B L
-Alg R2 U' R
-Alg R' U R2
-Alg R' U R'
-Alg F R F' U2
-Alg F' U F
-Alg F' U2 F
-Alg F' U' F
-Alg L F L'
-Alg L F2 L'
-Alg L F' L'
-Alg F' D R D'
-Alg F' U2 F U'
-Alg F D2 B D2 F'
-Alg F2 D' L2 D F2
-Alg F2 L F L' F
-Alg L' F2 L' F2 L
-Alg F L' U' L2 F L'
-Alg F2 L F L' U2 F
-Alg U
-Alg U2
-Alg U'
-Alg F2 D2 B D2 F2
-Alg F2 D2 B' D2 F2
-Alg L2 D2 R D2 L2
-Alg L2 D2 R' D2 L2
-Alg F2 D2 B D2 F2 U
-Alg F2 D2 B D2 F2 U'
-Alg U F2 D2 B D2 F2
-Alg U F2 D2 B' D2 F2
-Alg F D B D' R' F' U
-Alg F' D L F U B' L'
-Alg F' L' F U L U L'
-Alg D' L F D R' U' F'
-Alg L F L' U' F' U' F
-Alg L D' F' L' U' R F
-Alg F D F U F' L' F' R'
-Alg F2 D' F L F2 D F' R'
-Alg F D' F L' D F R2 U2 F' U'
-Alg F D' L D' L F D2 L2 B' R'
-Alg F L' D F R2 D2 L D F' U2
-Alg F L' D F2 D' L F L2 F2 U
-Alg F D F' D L2 F R' F' D' B2 U'`,
-  );
-}