cubing 0.22.0 → 0.24.0-pre2

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 (
-  typeof location !== "undefined" &&
-  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,171 +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";
-
-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,
-        );
-      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 impct on page performance. Try importing from the top level of `cubing/solve`?",
-    );
-  }
-}

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.ts

@@ -1,92 +0,0 @@
-import type { Alg } from "../../../../alg";
-import {
-  KPuzzle,
-  KPuzzleDefinition,
-  Transformation,
-} from "../../../../kpuzzle";
-import { puzzles } from "../../../../puzzles";
-import { mustBeInsideWorker } from "../../inside-worker";
-import {
-  randomPermute,
-  randomUIntBelowFactory,
-} from "../vendor/random-uint-below";
-import type { SGSCachedData } from "../parseSGS";
-import { TrembleSolver } from "../tremble";
-
-// Empirical ly determined depth:
-// - ≈11 moves on average (as opposed to >13 moves for depth 2),
-// - in close to 40ms(on a MacBook Pro).
-const TREMBLE_DEPTH = 3;
-
-let cachedTrembleSolver: Promise<TrembleSolver> | null = null;
-async function getCachedTrembleSolver(): Promise<TrembleSolver> {
-  return (
-    cachedTrembleSolver ||
-    (cachedTrembleSolver = (async (): Promise<TrembleSolver> => {
-      const json: SGSCachedData = await (
-        await import("./2x2x2.sgs.json")
-      ).cachedData222();
-      return new TrembleSolver(
-        await puzzles["2x2x2"].def(),
-        json,
-        "URFLBD".split(""),
-      );
-    })())
-  );
-}
-
-export async function preInitialize222(): Promise<void> {
-  await getCachedTrembleSolver();
-}
-
-// TODO: fix def consistency.
-export async function solve222(state: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  const trembleSolver = await getCachedTrembleSolver();
-  const alg = await trembleSolver.solve(state, TREMBLE_DEPTH, () => 4); // TODO: Attach quantum move order lookup to puzzle.
-  return alg;
-}
-
-// TODO: factor out and test.
-async function randomizeOrbit(
-  def: KPuzzleDefinition,
-  orbitName: string,
-  state: Transformation,
-  options?: { orientationSum?: number },
-): Promise<void> {
-  const randomUIntBelow = await randomUIntBelowFactory();
-  await randomPermute(state[orbitName].permutation);
-
-  const orbitDef = def.orbits[orbitName];
-  const ori = state[orbitName].orientation;
-
-  let sum = 0;
-  for (let i = 0; i < orbitDef.numPieces; i++) {
-    const o = randomUIntBelow(orbitDef.orientations);
-    ori[i] = o;
-    sum += o;
-  }
-
-  // console.log("aaaa", options && "orientationSum" in options);
-  if (options && "orientationSum" in options) {
-    // console.log("sfdsf", options!.orientationSum),
-    ori[0] =
-      (((ori[0] + options.orientationSum! - sum) % orbitDef.orientations) +
-        orbitDef.orientations) %
-      orbitDef.orientations;
-  }
-}
-
-// TODO: Use SGS?
-export async function random222State(): Promise<Transformation> {
-  const nonExtensibleDef = await puzzles["2x2x2"].def();
-  const def = Object.assign({}, nonExtensibleDef);
-  const kpuzzle = new KPuzzle(def);
-  const stateCopy: Transformation = JSON.parse(JSON.stringify(kpuzzle.state)); // TODO
-  await randomizeOrbit(def, "CORNERS", stateCopy, { orientationSum: 0 });
-  return stateCopy;
-}
-
-export async function random222Scramble(): Promise<Alg> {
-  return await solve222(await random222State());
-}