cube-state-engine 1.0.2 → 1.0.3

package/dist/index.mjs

@@ -0,0 +1,261 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.js
+var _CubeEngine_instances, switchMatrix_fn, specialFlip_fn;
+var CubeEngine = class {
+  constructor() {
+    __privateAdd(this, _CubeEngine_instances);
+    // States object for the rotation
+    __publicField(this, "STATES", {
+      UPPER: [
+        // (White)
+        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
+        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
+        [COLOR.W[6], COLOR.W[7], COLOR.W[8]]
+      ],
+      LEFT: [
+        // (Orange)
+        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
+        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
+        [COLOR.O[6], COLOR.O[7], COLOR.O[8]]
+      ],
+      FRONT: [
+        // (Green)
+        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
+        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
+        [COLOR.G[6], COLOR.G[7], COLOR.G[8]]
+      ],
+      RIGHT: [
+        // (Red)
+        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
+        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
+        [COLOR.R[6], COLOR.R[7], COLOR.R[8]]
+      ],
+      BACK: [
+        // (Blue)
+        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
+        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
+        [COLOR.B[6], COLOR.B[7], COLOR.B[8]]
+      ],
+      DOWN: [
+        // (Yellow)
+        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
+        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
+        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
+      ]
+    });
+  }
+  /**
+   * Rotates the top (U) layer clockwise or counterclockwise.
+   */
+  rotateU(clockwise = true) {
+    if (clockwise) {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempRight];
+      this.STATES.LEFT[0] = [...tempFront];
+      this.STATES.BACK[0] = [...tempLeft];
+      this.STATES.RIGHT[0] = [...tempBack];
+    } else {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempLeft];
+      this.STATES.LEFT[0] = [...tempBack];
+      this.STATES.BACK[0] = [...tempRight];
+      this.STATES.RIGHT[0] = [...tempFront];
+    }
+  }
+  /**
+   * Rotates the front (F) layer clockwise or counterclockwise.
+   */
+  rotateF(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+    }
+  }
+  rotateR(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(false);
+    } else {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(false);
+    }
+  }
+  rotateL(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(true);
+    } else {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(true);
+    }
+  }
+  rotateD(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateF(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateF(false);
+      this.rotateX(false);
+    }
+  }
+  /**
+   * Rotates the (x) axis clockwise or counterclockwise.
+   */
+  rotateX(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    if (clockwise) {
+      this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
+      this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
+      this.STATES.FRONT = [...tempDown];
+      this.STATES.UPPER = [...tempFront];
+      this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempUpper);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
+    } else {
+      this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
+      this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
+      this.STATES.FRONT = [...tempUpper];
+      this.STATES.DOWN = [...tempFront];
+      this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempDown);
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
+    }
+  }
+  /**
+   * Rotates the (y) axis clockwise or counterclockwise.
+   */
+  rotateY(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    if (clockwise) {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, false);
+      this.STATES.FRONT = [...tempRight];
+      this.STATES.RIGHT = [...tempBack];
+      this.STATES.LEFT = [...tempFront];
+      this.STATES.BACK = [...tempLeft];
+    } else {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, true);
+      this.STATES.FRONT = [...tempLeft];
+      this.STATES.RIGHT = [...tempFront];
+      this.STATES.LEFT = [...tempBack];
+      this.STATES.BACK = [...tempRight];
+    }
+  }
+  /**
+   * Logs the current state of the cube.
+   */
+  state() {
+    console.clear();
+    console.log(__spreadValues({}, this.STATES));
+    return __spreadValues({}, this.STATES);
+  }
+  /**
+   * Indicates if the cube is solve or not in all layers.
+   */
+  isSolved() {
+    const temp = __spreadValues({}, this.STATES);
+    const layersSolved = Object.keys(temp).map((layer) => {
+      const mixedMatrix = [
+        ...temp[layer][0],
+        ...temp[layer][1],
+        ...temp[layer][2]
+      ];
+      const centerColor = mixedMatrix[4];
+      return mixedMatrix.every((currentColor) => currentColor === centerColor);
+    });
+    return layersSolved.every((isLayerSolved) => isLayerSolved);
+  }
+};
+_CubeEngine_instances = new WeakSet();
+/**
+ * Rotate the entire face in the direction set
+ */
+switchMatrix_fn = function(matrix, clockwise = true) {
+  const clone = structuredClone(matrix);
+  const tempMatrix = [...clone[0], ...clone[1], ...clone[2]];
+  if (clockwise) {
+    return [
+      [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
+      [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
+      [tempMatrix[8], tempMatrix[5], tempMatrix[2]]
+    ];
+  } else {
+    return [
+      [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+      [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+      [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
+    ];
+  }
+};
+specialFlip_fn = function(matrix) {
+  return structuredClone(matrix).reverse().map((row) => [...row].reverse());
+};
+var COLOR = {
+  W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
+  G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],
+  R: ["R", "R", "R", "R", "R", "R", "R", "R", "R"],
+  B: ["B", "B", "B", "B", "B", "B", "B", "B", "B"],
+  O: ["O", "O", "O", "O", "O", "O", "O", "O", "O"],
+  Y: ["Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"]
+};
+export {
+  COLOR,
+  CubeEngine
+};

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "cube-state-engine",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "An efficient representation in memory for tracking the Rubik's cube state on each movement.",
-  "main": "./src/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "jest --watch"
+    "test": "jest --watch",
+    "build": "tsup src/index.js --format cjs,esm --dts",
+    "lint": "tsc"
   },
   "keywords": [
     "rubiks-cube",
@@ -23,6 +27,8 @@
     "@babel/core": "7.26.0",
     "@babel/preset-env": "7.26.0",
     "babel-jest": "29.7.0",
-    "jest": "29.7.0"
+    "jest": "29.7.0",
+    "tsup": "8.3.5",
+    "typescript": "5.7.2"
   }
 }

package/babel.config.js

@@ -1,3 +0,0 @@
-module.exports = {
-  presets: [["@babel/preset-env", { targets: { node: "current" } }]],
-};

package/index.html

@@ -1,107 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <script src="https://cdn.tailwindcss.com"></script>
-    <link href="styles.css" rel="stylesheet" />
-    <script
-      src="https://cdn.cubing.net/v0/js/cubing/twisty"
-      type="module"
-    ></script>
-    <title>Cube Engine Sample</title>
-  </head>
-  <body class="max-w-xl p-10 mx-auto font-serif">
-    <h1 class="mt-5 mb-5 text-2xl text-center font-bold">CUBE STATE ENGINE</h1>
-    <p class="mb-10">
-      It's a core state manager that should be able to integrate with custom 3D
-      cube models, making it easy to track and update the cube's state after
-      every move, providing context information, such as when it's solved.
-    </p>
-
-    <h3 class="font-bold">Docs</h3>
-
-    <pre class="mb-5">
-class CubeEngine {
-  isSolved():boolean,
-  state(): {
-    UPPER: string[][];
-    LEFT: string[][];
-    FRONT: string[][];
-    RIGHT: string[][];
-    BACK: string[][];
-    DOWN: string[][];
-  }
-  rotateU(clockwise: boolean): void,
-  rotateF(clockwise: boolean): void,
-  rotateD(clockwise: boolean): void,
-  rotateX(clockwise: boolean): void,
-  rotateY(clockwise: boolean): void,
-  rotateL(clockwise: boolean): void,
-  rotateR(clockwise: boolean): void,
-}
-</pre
-    >
-
-    <h3 class="font-bold mb-5">Sample usage</h3>
-    <p>
-      In this example, I am demonstrating 3D visualization of a Rubik's Cube
-      using the Cubing.js library. You can replace it with any other
-      configuration if desired. I have set up the controls to work with the
-      keyboard, allowing you to interact with the cube. Specially, you can track
-      when the cube is solved.
-    </p>
-
-    <pre class="mt-5 animate-pulse">
-CONTROLS_KEYBOARD: {
-  LEFT_HAND: A,S,D,F,G,E,T, 
-  RIGHT_HAND: H,J,K,L,Ñ/;,I,B,Y 
-}
-      </pre
-    >
-    <section
-      class="flex flex-col items-center justify-center gap-10 sm:flex-row"
-    >
-      <div class="flex-col">
-        <h2 class="mb-3 font-bold">3D</h2>
-        <twisty-player
-          style="width: 200px; height: 200px"
-          controlPanel="none"
-          back-view="top-right"
-        ></twisty-player>
-      </div>
-
-      <div class="flex-col">
-        <h2 class="mb-3 font-bold">Memory</h2>
-        <div
-          class="w-[200px] h-[200px] flex justify-center items-center relative text-xs"
-        >
-          <div class="absolute top-16 left-1" id="LEFT"></div>
-
-          <div class="absolute top-16 left-12" id="FRONT"></div>
-
-          <div class="absolute top-16 left-24" id="RIGHT"></div>
-
-          <div class="absolute top-16 left-36" id="BACK"></div>
-
-          <div class="absolute top-0 left-12" id="UPPER"></div>
-
-          <div class="absolute top-32 left-12" id="DOWN"></div>
-        </div>
-      </div>
-    </section>
-
-    <section class="w-full mt-5 text-start">
-      <div class="font-black">
-        isSolved?: <span class="font-normal" id="is-solve">true</span>
-      </div>
-      <div class="font-black">
-        Moves: <span class="font-normal" id="total">0</span>
-      </div>
-      <div>
-        <span class="font-black">Historial: </span><span id="moves"></span>
-      </div>
-    </section>
-    <script src="main.js" type="module"></script>
-  </body>
-</html>

package/jest.config.js

@@ -1,198 +0,0 @@
-/**
- * For a detailed explanation regarding each configuration property, visit:
- * https://jestjs.io/docs/configuration
- */
-
-/** @type {import('jest').Config} */
-const config = {
-  // All imported modules in your tests should be mocked automatically
-  // automock: false,
-
-  // Stop running tests after `n` failures
-  // bail: 0,
-
-  // The directory where Jest should store its cached dependency information
-  // cacheDirectory: "C:\\Users\\bryan\\AppData\\Local\\Temp\\jest",
-
-  // Automatically clear mock calls, instances, contexts and results before every test
-  clearMocks: true,
-
-  // Indicates whether the coverage information should be collected while executing the test
-  collectCoverage: true,
-
-  // An array of glob patterns indicating a set of files for which coverage information should be collected
-  // collectCoverageFrom: undefined,
-
-  // The directory where Jest should output its coverage files
-  coverageDirectory: "coverage",
-
-  // An array of regexp pattern strings used to skip coverage collection
-  // coveragePathIgnorePatterns: [
-  //   "\\\\node_modules\\\\"
-  // ],
-
-  // Indicates which provider should be used to instrument code for coverage
-  coverageProvider: "v8",
-
-  // A list of reporter names that Jest uses when writing coverage reports
-  // coverageReporters: [
-  //   "json",
-  //   "text",
-  //   "lcov",
-  //   "clover"
-  // ],
-
-  // An object that configures minimum threshold enforcement for coverage results
-  // coverageThreshold: undefined,
-
-  // A path to a custom dependency extractor
-  // dependencyExtractor: undefined,
-
-  // Make calling deprecated APIs throw helpful error messages
-  // errorOnDeprecated: false,
-
-  // The default configuration for fake timers
-  // fakeTimers: {
-  //   "enableGlobally": false
-  // },
-
-  // Force coverage collection from ignored files using an array of glob patterns
-  // forceCoverageMatch: [],
-
-  // A path to a module which exports an async function that is triggered once before all test suites
-  // globalSetup: undefined,
-
-  // A path to a module which exports an async function that is triggered once after all test suites
-  // globalTeardown: undefined,
-
-  // A set of global variables that need to be available in all test environments
-  // globals: {},
-
-  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
-  // maxWorkers: "50%",
-
-  // An array of directory names to be searched recursively up from the requiring module's location
-  // moduleDirectories: [
-  //   "node_modules"
-  // ],
-
-  // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "mjs",
-  //   "cjs",
-  //   "jsx",
-  //   "ts",
-  //   "tsx",
-  //   "json",
-  //   "node"
-  // ],
-
-  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  // moduleNameMapper: {},
-
-  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
-
-  // Activates notifications for test results
-  // notify: false,
-
-  // An enum that specifies notification mode. Requires { notify: true }
-  // notifyMode: "failure-change",
-
-  // A preset that is used as a base for Jest's configuration
-  // preset: undefined,
-
-  // Run tests from one or more projects
-  // projects: undefined,
-
-  // Use this configuration option to add custom reporters to Jest
-  // reporters: undefined,
-
-  // Automatically reset mock state before every test
-  // resetMocks: false,
-
-  // Reset the module registry before running each individual test
-  // resetModules: false,
-
-  // A path to a custom resolver
-  // resolver: undefined,
-
-  // Automatically restore mock state and implementation before every test
-  // restoreMocks: false,
-
-  // The root directory that Jest should scan for tests and modules within
-  // rootDir: undefined,
-
-  // A list of paths to directories that Jest should use to search for files in
-  // roots: [
-  //   "<rootDir>"
-  // ],
-
-  // Allows you to use a custom runner instead of Jest's default test runner
-  // runner: "jest-runner",
-
-  // The paths to modules that run some code to configure or set up the testing environment before each test
-  // setupFiles: [],
-
-  // A list of paths to modules that run some code to configure or set up the testing framework before each test
-  // setupFilesAfterEnv: [],
-
-  // The number of seconds after which a test is considered as slow and reported as such in the results.
-  // slowTestThreshold: 5,
-
-  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
-  // snapshotSerializers: [],
-
-  // The test environment that will be used for testing
-  testEnvironment: "node",
-
-  // Options that will be passed to the testEnvironment
-  // testEnvironmentOptions: {},
-
-  // Adds a location field to test results
-  // testLocationInResults: false,
-
-  // The glob patterns Jest uses to detect test files
-  // testMatch: [
-  //   "**/__tests__/**/*.[jt]s?(x)",
-  //   "**/?(*.)+(spec|test).[tj]s?(x)"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-  // testPathIgnorePatterns: [
-  //   "\\\\node_modules\\\\"
-  // ],
-
-  // The regexp pattern or array of patterns that Jest uses to detect test files
-  // testRegex: [],
-
-  // This option allows the use of a custom results processor
-  // testResultsProcessor: undefined,
-
-  // This option allows use of a custom test runner
-  // testRunner: "jest-circus/runner",
-
-  // A map from regular expressions to paths to transformers
-  // transform: undefined,
-
-  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
-  // transformIgnorePatterns: [
-  //   "\\\\node_modules\\\\",
-  //   "\\.pnp\\.[^\\\\]+$"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
-  // unmockedModulePathPatterns: undefined,
-
-  // Indicates whether each individual test should be reported during the run
-  // verbose: undefined,
-
-  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
-  // watchPathIgnorePatterns: [],
-
-  // Whether to use watchman for file crawling
-  // watchman: true,
-};
-
-module.exports = config;

package/main.js

@@ -1,62 +0,0 @@
-import { CubeEngine } from "./src/index.js";
-
-window.CubeEngine = new CubeEngine();
-render();
-
-const player = document.querySelector("twisty-player");
-const moves = [];
-
-/**
- * Key listener for cube movements.
- */
-document.addEventListener("keyup", (e) => {
-  const movesMap = {
-    f: { move: () => window.CubeEngine.rotateU(false), notation: "U'" },
-    j: { move: () => window.CubeEngine.rotateU(true), notation: "U" },
-    g: { move: () => window.CubeEngine.rotateF(false), notation: "F'" },
-    h: { move: () => window.CubeEngine.rotateF(true), notation: "F" },
-    i: { move: () => window.CubeEngine.rotateR(true), notation: "R" },
-    k: { move: () => window.CubeEngine.rotateR(false), notation: "R'" },
-    d: { move: () => window.CubeEngine.rotateL(true), notation: "L" },
-    e: { move: () => window.CubeEngine.rotateL(false), notation: "L'" },
-    t: { move: () => window.CubeEngine.rotateX(true), notation: "x" },
-    y: { move: () => window.CubeEngine.rotateX(true), notation: "x" },
-    b: { move: () => window.CubeEngine.rotateX(false), notation: "x'" },
-    n: { move: () => window.CubeEngine.rotateX(false), notation: "x'" },
-    ñ: { move: () => window.CubeEngine.rotateY(true), notation: "y" },
-    a: { move: () => window.CubeEngine.rotateY(false), notation: "y'" },
-    s: { move: () => window.CubeEngine.rotateD(true), notation: "D" },
-    l: { move: () => window.CubeEngine.rotateD(false), notation: "D'" },
-  };
-
-  const key = e.key.toLowerCase();
-  const moveObj = movesMap[key];
-
-  if (moveObj) {
-    moveObj.move();
-    moves.push(moveObj.notation);
-
-    // sync UI
-    document.querySelector("#total").textContent = moves.length;
-    document.querySelector("#moves").textContent = moves.join(" ");
-    document.querySelector(
-      "#is-solve"
-    ).textContent = `${window.CubeEngine.isSolved()}`;
-    player.alg = moves.join(" ");
-    render();
-  }
-});
-
-function render() {
-  const state = window.CubeEngine.state();
-  Object.keys(state).forEach((layer) => {
-    const layerContent = state[layer]
-      .map(
-        (row) =>
-          `<div>${row.map((cell) => `<span>${cell}</span>`).join("")}</div>`
-      )
-      .join("");
-
-    document.querySelector(`#${layer}`).innerHTML = layerContent;
-  });
-}

package/styles.css

@@ -1,3 +0,0 @@
-body {
-  background-color: beige;
-}