cube-state-engine 1.0.5 → 1.1.0

package/dist/index.mjs

@@ -23,9 +23,9 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.js
-var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateX_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn;
+var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
 var CubeEngine = class {
-  constructor() {
+  constructor(initialScramble) {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
     // States object for the rotation
@@ -67,6 +67,10 @@ var CubeEngine = class {
         [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
       ]
     });
+    if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
+      __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, initialScramble, false);
+      this.MOVES = [];
+    }
   }
   /**
    * Rotates the (UPPER) layer clockwise or counterclockwise.
@@ -128,6 +132,66 @@ var CubeEngine = class {
       this.MOVES.push("D'");
     }
   }
+  /**
+   * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
+   */
+  rotateDw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true);
+      this.MOVES.push("Dw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false);
+      this.MOVES.push("Dw'");
+    }
+  }
+  /**
+   * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
+   */
+  rotateUw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true);
+      this.MOVES.push("Uw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false);
+      this.MOVES.push("Uw'");
+    }
+  }
+  /**
+   * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
+   */
+  rotateRw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true);
+      this.MOVES.push("Rw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false);
+      this.MOVES.push("Rw'");
+    }
+  }
+  /**
+   * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
+   */
+  rotateLw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
+      this.MOVES.push("Lw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
+      this.MOVES.push("Lw'");
+    }
+  }
+  /**
+   * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
+   */
+  rotateM(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true);
+      this.MOVES.push("M");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false);
+      this.MOVES.push("M'");
+    }
+  }
   /**
    * Rotates the (x) axis clockwise or counterclockwise.
    */
@@ -140,6 +204,18 @@ var CubeEngine = class {
       this.MOVES.push("x'");
     }
   }
+  /**
+   * Rotates the (z) axis clockwise or counterclockwise.
+   */
+  rotateZ(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true);
+      this.MOVES.push("z");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false);
+      this.MOVES.push("z'");
+    }
+  }
   /**
    * Rotates the (y) axis clockwise or counterclockwise.
    */
@@ -183,6 +259,16 @@ var CubeEngine = class {
   getMoves(asString = true) {
     return asString ? this.MOVES.join(" ") : this.MOVES;
   }
+  /**
+   * Applies a sequence of moves provided as a string.
+   * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
+   * @param {string} sequence - e.g. "R U' F R2 D Dw Uw Rw Rw' Lw Lw2 M M' M2"
+   * @param {object} options - { record: boolean } whether to record moves in history (default true)
+   */
+  applyMoves(sequence, options = { record: false }) {
+    const record = (options == null ? void 0 : options.record) !== false;
+    __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, sequence, record);
+  }
 };
 _CubeEngine_instances = new WeakSet();
 rotateU_fn = function(clockwise = true) {
@@ -260,6 +346,51 @@ rotateD_fn = function(clockwise = true) {
     __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
   }
 };
+rotateDw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
+  }
+};
+rotateUw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false);
+  }
+};
+rotateRw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
+  }
+};
+rotateLw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false);
+  }
+};
+rotateM_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
+  }
+};
 rotateX_fn = function(clockwise = true) {
   const tempFront = structuredClone(this.STATES.FRONT);
   const tempDown = structuredClone(this.STATES.DOWN);
@@ -283,6 +414,29 @@ rotateX_fn = function(clockwise = true) {
     this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
   }
 };
+rotateZ_fn = function(clockwise = true) {
+  const tempUpper = structuredClone(this.STATES.UPPER);
+  const tempRight = structuredClone(this.STATES.RIGHT);
+  const tempDown = structuredClone(this.STATES.DOWN);
+  const tempLeft = structuredClone(this.STATES.LEFT);
+  const tempFront = structuredClone(this.STATES.FRONT);
+  const tempBack = structuredClone(this.STATES.BACK);
+  if (clockwise) {
+    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, true);
+    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, false);
+    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, true);
+    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
+    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, true);
+    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
+  } else {
+    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, false);
+    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, true);
+    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, false);
+    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
+    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, false);
+    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
+  }
+};
 rotateY_fn = function(clockwise = true) {
   const tempFront = structuredClone(this.STATES.FRONT);
   const tempRight = structuredClone(this.STATES.RIGHT);
@@ -327,6 +481,128 @@ switchMatrix_fn = function(matrix, clockwise = true) {
 specialFlip_fn = function(matrix) {
   return structuredClone(matrix).reverse().map((row) => [...row].reverse());
 };
+// Internal: parses and applies moves. If record=false, uses private methods to avoid logging.
+applyMovesFromString_fn = function(sequence, record = true) {
+  if (typeof sequence !== "string") return;
+  const tokens = sequence.split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  for (const token of tokens) {
+    const base = token[0];
+    const rest = token.slice(1);
+    const isDouble = rest.includes("2");
+    const isPrime = rest.includes("'");
+    const times = isDouble ? 2 : 1;
+    const exec = (fnClockwise, fnCounter) => {
+      if (isDouble) {
+        fnClockwise();
+        fnClockwise();
+      } else {
+        if (isPrime) {
+          fnCounter();
+        } else {
+          fnClockwise();
+        }
+      }
+    };
+    switch (base) {
+      case "U":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateUw(true) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true),
+              () => record ? this.rotateUw(false) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateU(true) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true),
+              () => record ? this.rotateU(false) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "D":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateDw(true) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true),
+              () => record ? this.rotateDw(false) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateD(true) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true),
+              () => record ? this.rotateD(false) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "L":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateLw(true) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true),
+              () => record ? this.rotateLw(false) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateL(true) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true),
+              () => record ? this.rotateL(false) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "R":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateRw(true) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true),
+              () => record ? this.rotateRw(false) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateR(true) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true),
+              () => record ? this.rotateR(false) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "F":
+        exec(
+          () => record ? this.rotateF(true) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true),
+          () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
+        );
+        break;
+      case "x":
+        exec(
+          () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),
+          () => record ? this.rotateX(false) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false)
+        );
+        break;
+      case "y":
+        exec(
+          () => record ? this.rotateY(true) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true),
+          () => record ? this.rotateY(false) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false)
+        );
+        break;
+      case "z":
+        exec(
+          () => record ? this.rotateZ(true) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true),
+          () => record ? this.rotateZ(false) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false)
+        );
+        break;
+      case "M":
+        exec(
+          () => record ? this.rotateM(true) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true),
+          () => record ? this.rotateM(false) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false)
+        );
+        break;
+      default:
+        break;
+    }
+  }
+};
 var COLOR = {
   W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
   G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cube-state-engine",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "An efficient representation in memory for tracking the Rubik's cube state on each movement.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",