@houstonp/rubiks-cube 1.5.2 → 2.1.0

package/src/cube/stickerState.js

@@ -0,0 +1,188 @@
+// @ts-check
+/** @typedef {{ up: import('../core').Face[][], down: import('../core').Face[][], front: import('../core').Face[][], back: import('../core').Face[][], left: import('../core').Face[][], right: import('../core').Face[][] }} StickerState*/
+
+import { CubeTypes, Faces } from '../core';
+
+/**
+ *
+ * @param {import('../core').CubeType} cubeType
+ * @return {StickerState}
+ */
+export const defaultStickerState = (cubeType) => {
+    const length = 0;
+    switch (cubeType) {
+        case CubeTypes.Two:
+            return initialStickerState(2);
+        case CubeTypes.Three:
+            return initialStickerState(3);
+        case CubeTypes.Four:
+            return initialStickerState(4);
+        case CubeTypes.Five:
+            return initialStickerState(5);
+        case CubeTypes.Six:
+            return initialStickerState(6);
+        case CubeTypes.Seven:
+            return initialStickerState(7);
+        default:
+            throw new Error(`Unsupported cube type: ${cubeType}`);
+    }
+};
+
+/**
+ *
+ * @param {number} layerCount
+ * @returns {StickerState}
+ */
+const initialStickerState = (layerCount) => {
+    const state = {
+        right: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.R)),
+        up: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.U)),
+        front: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.F)),
+        back: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.B)),
+        down: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.D)),
+        left: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.L)),
+    };
+    return state;
+};
+
+/**
+ *
+ * @param {import('../core').CubeType} cubeType
+ * @return {StickerState}
+ */
+export const getEmptyStickerState = (cubeType) => {
+    const length = 0;
+    switch (cubeType) {
+        case CubeTypes.Two:
+            return emptyStickerState(2);
+        case CubeTypes.Three:
+            return emptyStickerState(3);
+        case CubeTypes.Four:
+            return emptyStickerState(4);
+        case CubeTypes.Five:
+            return emptyStickerState(5);
+        case CubeTypes.Six:
+            return emptyStickerState(6);
+        case CubeTypes.Seven:
+            return emptyStickerState(7);
+        default:
+            throw new Error(`Unsupported cube type: ${cubeType}`);
+    }
+};
+/**
+ *
+ * @param {number} layerCount
+ * @returns {StickerState}
+ */
+const emptyStickerState = (layerCount) => {
+    const state = {
+        right: Array.from({ length: layerCount }, () => []),
+        up: Array.from({ length: layerCount }, () => []),
+        front: Array.from({ length: layerCount }, () => []),
+        back: Array.from({ length: layerCount }, () => []),
+        down: Array.from({ length: layerCount }, () => []),
+        left: Array.from({ length: layerCount }, () => []),
+    };
+    return state;
+};
+
+/**
+ * @param {StickerState} stickerState
+ * @returns {string}
+ */
+export function toKociemba(stickerState) {
+    return `${stickerState.up.flat().join('')}${stickerState.right.flat().join('')}${stickerState.front.flat().join('')}${stickerState.down.flat().join('')}${stickerState.left.flat().join('')}${stickerState.back.flat().join('')}`;
+}
+
+/**
+ * @param {string} kociembaString
+ * @param {import('../core').CubeType} cubeType
+ * @returns {StickerState | undefined} stickerState
+ */
+export function fromKociemba(kociembaString, cubeType) {
+    const length = kociembaString.length;
+    switch (cubeType) {
+        case CubeTypes.Two:
+            if (length != 6 * 2 ** 2) {
+                console.error('Invalid state string length. Length must be 24 for 2x2 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 2);
+        case CubeTypes.Three:
+            if (length != 6 * 3 ** 2) {
+                console.error('Invalid state string length. Length must be 54 for 3x3 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 3);
+        case CubeTypes.Four:
+            if (length != 6 * 4 ** 2) {
+                console.error('Invalid state string length. Length must be 96 for 4x4 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 4);
+        case CubeTypes.Five:
+            if (length != 6 * 5 ** 2) {
+                console.error('Invalid state string length. Length must be 150 for 5x5 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 5);
+        case CubeTypes.Six:
+            if (length != 6 * 6 ** 2) {
+                console.error('Invalid state string length. Length must be 216 for 6x6 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 6);
+        case CubeTypes.Seven:
+            if (length != 6 * 7 ** 2) {
+                console.error('Invalid state string length. Length must be 294 for 7x7 cubes.');
+                return;
+            }
+            return fromKociembaWithLayerCount(kociembaString, 7);
+        default:
+            undefined;
+    }
+}
+
+/**
+ * @param {string} kociembaString
+ * @param {number} layerCount
+ * @returns {StickerState | undefined } stickerState
+ */
+function fromKociembaWithLayerCount(kociembaString, layerCount) {
+    let stickerState = emptyStickerState(layerCount);
+    for (let i = 0; i < 6; i++) {
+        const faceString = kociembaString.slice(i * layerCount ** 2, (i + 1) * layerCount ** 2);
+        for (let j = 0; j < layerCount; j++) {
+            const rowString = faceString.slice(j * layerCount, (j + 1) * layerCount);
+            for (let k = 0; k < layerCount; k++) {
+                const face = Object.values(Faces).find((face) => rowString[k] === face);
+                if (!face) {
+                    return undefined;
+                }
+                switch (i) {
+                    case 0:
+                        stickerState.up[j][k] = face;
+                        break;
+                    case 1:
+                        stickerState.right[j][k] = face;
+                        break;
+                    case 2:
+                        stickerState.front[j][k] = face;
+                        break;
+                    case 3:
+                        stickerState.down[j][k] = face;
+                        break;
+                    case 4:
+                        stickerState.left[j][k] = face;
+                        break;
+                    case 5:
+                        stickerState.back[j][k] = face;
+                        break;
+                    default:
+                        throw new Error(`Invalid value for i - [${i}]. i should be between [0,5] inclusive.`);
+                }
+            }
+        }
+    }
+    return stickerState;
+}

package/src/debouncer.js

@@ -0,0 +1,16 @@
+// @ts-check
+/**
+ * @param {number} delay
+ * @param {{ (entries: { contentRect: { width: number; height: number; }; }[]): void; apply?: any; }} f
+ */
+export function debounce(f, delay) {
+    let timer = 0;
+    /**
+     * @this {any}
+     * @param {any[]} args
+     */
+    return function (...args) {
+        clearTimeout(timer);
+        timer = window.setTimeout(() => f.apply(this, args), delay);
+    };
+}

package/src/globals.ts

@@ -0,0 +1,9 @@
+import { RubiksCubeElement } from '.';
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'rubiks-cube': RubiksCubeElement;
+    }
+}
+
+export {};