@houstonp/rubiks-cube 2.0.0 → 3.0.0

package/src/state/stickerState.js

@@ -0,0 +1,185 @@
+// @ts-check
+import { CubeTypes, Faces } from '../core';
+/** @import {Face, CubeType} from '../core' */
+/** @import {vector} from './rubiksCubeState' */
+
+/**
+ * @typedef StickerState
+ * @property {Face[][]} Face.U
+ * @property {Face[][]} Face.D
+ * @property {Face[][]} Face.F
+ * @property {Face[][]} Face.B
+ * @property {Face[][]} Face.L
+ * @property {Face[][]} Face.R
+ **/
+
+const ERROR_MARGIN = 0.0001;
+const LayerCount = {
+    [CubeTypes.Two]: 2,
+    [CubeTypes.Three]: 3,
+    [CubeTypes.Four]: 4,
+    [CubeTypes.Five]: 5,
+    [CubeTypes.Six]: 6,
+    [CubeTypes.Seven]: 7,
+};
+
+/**
+ * @param {vector} stickerDirection
+ * @param {vector} piecePosition
+ * @param {number[]} layers
+ * @returns {{face: Face, i: number, j: number}}
+ */
+export function getStickerFaceIndex(stickerDirection, piecePosition, layers) {
+    const last = layers.length - 1;
+    /** @type {(val: number) => number} */
+    const layerIndex = (val) => {
+        for (let i = 0; i < layers.length; i++) {
+            if (Math.abs(val - layers[i]) < ERROR_MARGIN) {
+                return i;
+            }
+        }
+        throw new Error(`Failed to get layer number. position ${val} not found in layers ${layers}`);
+    };
+    if (stickerDirection.x === 1) return { face: Faces.R, i: last - layerIndex(piecePosition.y), j: last - layerIndex(piecePosition.z) };
+    if (stickerDirection.x === -1) return { face: Faces.L, i: last - layerIndex(piecePosition.y), j: layerIndex(piecePosition.z) };
+    if (stickerDirection.y === 1) return { face: Faces.U, i: layerIndex(piecePosition.z), j: layerIndex(piecePosition.x) };
+    if (stickerDirection.y === -1) return { face: Faces.D, i: last - layerIndex(piecePosition.z), j: layerIndex(piecePosition.x) };
+    if (stickerDirection.z === 1) return { face: Faces.F, i: last - layerIndex(piecePosition.y), j: layerIndex(piecePosition.x) };
+    if (stickerDirection.z === -1) return { face: Faces.B, i: last - layerIndex(piecePosition.y), j: last - layerIndex(piecePosition.x) };
+    throw new Error(`StickerDirection is not a standard unit vector. vector: ${stickerDirection}`);
+}
+
+/**
+ *
+ * @param {CubeType} cubeType
+ * @return {StickerState}
+ */
+export const defaultStickerState = (cubeType) => {
+    const n = LayerCount[cubeType];
+    if (n == null) {
+        throw new Error(`Invalid CubeType`);
+    }
+    return initialStickerState(n);
+};
+
+/**
+ *
+ * @param {number} layerCount
+ * @returns {StickerState}
+ */
+const initialStickerState = (layerCount) => {
+    const state = {
+        [Faces.R]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.R)),
+        [Faces.U]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.U)),
+        [Faces.F]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.F)),
+        [Faces.B]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.B)),
+        [Faces.D]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.D)),
+        [Faces.L]: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.L)),
+    };
+    return state;
+};
+
+/**
+ *
+ * @param {CubeType} cubeType
+ * @return {StickerState}
+ */
+export const getEmptyStickerState = (cubeType) => {
+    const n = LayerCount[cubeType];
+    if (n == null) {
+        throw new Error(`Invalid CubeType`);
+    }
+    return emptyStickerState(n);
+};
+/**
+ *
+ * @param {number} layerCount
+ * @returns {StickerState}
+ */
+const emptyStickerState = (layerCount) => {
+    const state = {
+        [Faces.R]: Array.from({ length: layerCount }, () => []),
+        [Faces.U]: Array.from({ length: layerCount }, () => []),
+        [Faces.F]: Array.from({ length: layerCount }, () => []),
+        [Faces.B]: Array.from({ length: layerCount }, () => []),
+        [Faces.D]: Array.from({ length: layerCount }, () => []),
+        [Faces.L]: Array.from({ length: layerCount }, () => []),
+    };
+    return state;
+};
+
+/**
+ * @param {StickerState} stickerState
+ * @returns {string}
+ */
+export function toKociemba(stickerState) {
+    return `${stickerState.U.flat().join('')}${stickerState.R.flat().join('')}${stickerState.F.flat().join('')}${stickerState.D.flat().join('')}${stickerState.L.flat().join('')}${stickerState.B.flat().join('')}`;
+}
+
+/**
+ * @param {string} kociembaString
+ * @returns {StickerState | undefined} stickerState
+ */
+export function fromKociemba(kociembaString) {
+    switch (kociembaString.length) {
+        case 6 * 2 * 2:
+            return fromKociembaWithLayerCount(kociembaString, 2);
+        case 6 * 3 * 3:
+            return fromKociembaWithLayerCount(kociembaString, 3);
+        case 6 * 4 * 4:
+            return fromKociembaWithLayerCount(kociembaString, 4);
+        case 6 * 5 * 5:
+            return fromKociembaWithLayerCount(kociembaString, 5);
+        case 6 * 6 * 6:
+            return fromKociembaWithLayerCount(kociembaString, 6);
+        case 6 * 7 * 7:
+            return fromKociembaWithLayerCount(kociembaString, 7);
+        default:
+            console.error(`Invalid state string length.`);
+            return;
+    }
+}
+
+/**
+ * @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.U[j][k] = face;
+                        break;
+                    case 1:
+                        stickerState.R[j][k] = face;
+                        break;
+                    case 2:
+                        stickerState.F[j][k] = face;
+                        break;
+                    case 3:
+                        stickerState.D[j][k] = face;
+                        break;
+                    case 4:
+                        stickerState.L[j][k] = face;
+                        break;
+                    case 5:
+                        stickerState.B[j][k] = face;
+                        break;
+                    default:
+                        throw new Error(`Invalid value for i - [${i}]. i should be between [0,5] inclusive.`);
+                }
+            }
+        }
+    }
+    return stickerState;
+}

package/src/{cameraState.js → webComponent/cameraState.js}

@@ -1,5 +1,6 @@
 // @ts-check
-import { PeekStates, PeekTypes } from './core';
+import { PeekActions, PeekStates } from './constants';
+/** @import {PeekAction, PeekState} from './constants' */
 
 export class CameraState {
     /**
@@ -14,51 +15,48 @@ export class CameraState {
     }
 
     /**
-     * @param {import("./core").PeekType} peekType
+     * @param {PeekAction} action
      */
-    peekCamera(peekType) {
-        switch (peekType) {
-            case PeekTypes.Horizontal:
+    peekCamera(action) {
+        switch (action) {
+            case PeekActions.Horizontal:
                 this.Right = !this.Right;
                 break;
-            case PeekTypes.Vertical:
+            case PeekActions.Vertical:
                 this.Up = !this.Up;
                 break;
-            case PeekTypes.Right:
+            case PeekActions.Right:
                 this.Right = true;
                 break;
-            case PeekTypes.Left:
+            case PeekActions.Left:
                 this.Right = false;
                 break;
-            case PeekTypes.Up:
+            case PeekActions.Up:
                 this.Up = true;
                 break;
-            case PeekTypes.Down:
+            case PeekActions.Down:
                 this.Up = false;
                 break;
-            case PeekTypes.RightUp:
+            case PeekActions.RightUp:
                 this.Right = true;
                 this.Up = true;
                 break;
-            case PeekTypes.RightDown:
+            case PeekActions.RightDown:
                 this.Right = true;
                 this.Up = false;
                 break;
-            case PeekTypes.LeftUp:
+            case PeekActions.LeftUp:
                 this.Right = false;
                 this.Up = true;
                 break;
-            case PeekTypes.LeftDown:
+            case PeekActions.LeftDown:
                 this.Right = false;
                 this.Up = false;
                 break;
-            default:
-                console.error(`Invalid peekType:[${peekType}]. valid values are [${Object.values(PeekTypes)}] `);
-                break;
         }
     }
     /**
-     * @returns {import("./core").PeekState}
+     * @returns {PeekState}
      */
     toPeekState() {
         if (this.Right && this.Up) {
@@ -70,12 +68,6 @@ export class CameraState {
         if (this.Right && !this.Up) {
             return PeekStates.RightDown;
         }
-        if (!this.Right && !this.Up) {
-            return PeekStates.LeftDown;
-        }
-        console.error(
-            `Invalid CameraState right and up values must be true or false. Actual values: right[${this.Right}] up[${this.Up}]. Default RightUp returned`,
-        );
-        return PeekStates.RightUp;
+        return PeekStates.LeftDown;
     }
 }

package/src/webComponent/constants.js

@@ -0,0 +1,67 @@
+/**
+ * @typedef CameraOptions
+ * @property {number} [cameraSpeedMs]
+ */
+
+/**
+ * @typedef {typeof AnimationStyles[keyof typeof AnimationStyles]} AnimationStyle
+ */
+export const AnimationStyles = Object.freeze({
+    Exponential: 'exponential',
+    Linear: 'linear',
+    Next: 'next',
+    Fixed: 'fixed',
+    Match: 'match',
+});
+
+/**
+ * @typedef {typeof PeekStates [keyof typeof PeekStates]} PeekState
+ */
+export const PeekStates = Object.freeze({
+    RightUp: 'rightUp',
+    RightDown: 'rightDown',
+    LeftUp: 'leftUp',
+    LeftDown: 'leftDown',
+});
+
+/**
+ * @typedef {typeof PeekActions [keyof typeof PeekActions]} PeekAction
+ */
+export const PeekActions = Object.freeze({
+    Horizontal: 'horizontal',
+    Vertical: 'vertical',
+    Right: 'right',
+    Left: 'left',
+    Up: 'up',
+    Down: 'down',
+    RightUp: 'rightUp',
+    RightDown: 'rightDown',
+    LeftUp: 'leftUp',
+    LeftDown: 'leftDown',
+});
+
+/**
+ * @typedef {typeof AttributeNames[keyof typeof AttributeNames]} AttributeName
+ */
+export const AttributeNames = {
+    /** @type {'cube-type'} */
+    cubeType: 'cube-type',
+    /** @type {'piece-gap'} */
+    pieceGap: 'piece-gap',
+    /** @type {'animation-speed-ms'} */
+    animationSpeed: 'animation-speed-ms',
+    /** @type {'animation-style'} */
+    animationStyle: 'animation-style',
+    /** @type {'camera-speed-ms'} */
+    cameraSpeed: 'camera-speed-ms',
+    /** @type {'camera-radius'} */
+    cameraRadius: 'camera-radius',
+    /** @type {'camera-field-of-view'} */
+    cameraFieldOfView: 'camera-field-of-view',
+    /** @type {'camera-peek-angle-horizontal'} */
+    cameraPeekAngleHorizontal: 'camera-peek-angle-horizontal',
+    /** @type {'camera-peek-angle-vertical'} */
+    cameraPeekAngleVertical: 'camera-peek-angle-vertical',
+    /** @type {'logo'} */
+    logo: 'logo',
+};

package/src/{debouncer.js → webComponent/debouncer.js}

@@ -11,6 +11,6 @@ export function debounce(f, delay) {
      */
     return function (...args) {
         clearTimeout(timer);
-        timer = setTimeout(() => f.apply(this, args), delay);
+        timer = window.setTimeout(() => f.apply(this, args), delay);
     };
 }

package/src/webComponent/index.js

@@ -0,0 +1,7 @@
+// @ts-check
+/** @typedef {import("./constants").PeekState} PeekState */
+/** @typedef {import("./constants").PeekAction} PeekAction */
+/** @typedef {import("./constants").CameraOptions} CameraOptions */
+/** @typedef {import('./constants').AnimationStyle} AnimationStyle */
+export { RubiksCubeElement } from './rubiksCubeElement';
+export { AttributeNames, PeekStates, PeekActions, AnimationStyles } from './constants';