@houstonp/rubiks-cube 1.5.2 → 2.1.0

package/tests/cube.two.test.js

@@ -0,0 +1,125 @@
+// @ts-check
+import './setup.js';
+import { describe, it, expect, test } from 'bun:test';
+import { CubeTypes, Movements, Rotations } from '../src/core.js';
+import { toKociemba } from '../src/cube/stickerState.js';
+import { createTestCube, drainUpdates } from './common.js';
+
+describe('2x2 Tests', () => {
+    it('Valid initial Kociemba state string', () => {
+        //Arange
+        const cube = createTestCube(CubeTypes.Two);
+
+        //Act
+        const state = toKociemba(cube._cubeInfo.initialStickerState);
+
+        //Assert
+        expect(state.length).toBe(24);
+        for (const ch of state) {
+            expect('UDLRFB').toContain(ch);
+        }
+
+        const counts = {
+            U: 0,
+            D: 0,
+            L: 0,
+            R: 0,
+            F: 0,
+            B: 0,
+        };
+        for (const ch of state) {
+            const face = /** @type {"R" | "U" | "F" | "L" | "D" | "B"} */ (ch);
+            counts[face]++;
+        }
+        expect(Object.values(counts).every((c) => c === 4)).toBe(true);
+    });
+
+    it('reset method returns the cube to the initial state', () => {
+        // Arrange
+        const cube = createTestCube(CubeTypes.Two);
+        const initialState = toKociemba(cube._cubeInfo.initialStickerState);
+        /** @type {string?} */
+        let completedState = null;
+        /** @type {string?} */
+        let failedReason = null;
+        cube.movement(
+            Movements.Single.R,
+            (state) => {
+                completedState = state;
+                return true;
+            },
+            (reason) => {
+                failedReason = reason;
+                return true;
+            },
+        );
+        drainUpdates(cube);
+
+        // Act
+        /** @type {string?} */
+        let resetState = null;
+        cube.reset((state) => {
+            resetState = state;
+            return true;
+        });
+        drainUpdates(cube);
+
+        // Assert
+        expect(failedReason).toBeNull();
+        expect(completedState).not.toBeNull();
+        expect(completedState).not.toBe(initialState);
+        expect(/** @type {string?} **/ (resetState)).toBe(initialState);
+    });
+
+    it('solve', () => {
+        // Arrange
+        const cube = createTestCube(CubeTypes.Two);
+        const scramble = "D U R2 B2 D' B2 D R2 F2 L2 R B U2 R2 U' B' L D' R U' R";
+        const scrambleMoves = /** @type {import('../src/core.js').Movement[]} */ (scramble.split(' '));
+
+        for (const move of scrambleMoves) {
+            cube.movement(
+                move,
+                () => {},
+                () => {
+                    throw new Error('Movement failed unexpectedly');
+                },
+            );
+            drainUpdates(cube);
+        }
+
+        // Act
+        const solution =
+            "D L R' F R D2 R U' R' F U R U2' R' U R U' R' U' L U L' D U L' U' L U2 L' U L L F' L' F U R' U2 R U2' R' U R U2' R' U R U2' R' U' R U y'";
+        const solutionActions = /** @type {(import('../src/core.js').Movement | import('../src/core.js').Rotation)[]} */ (solution.split(' '));
+
+        let finalState = null;
+        for (const action of solutionActions) {
+            if (action.includes('x') || action.includes('y') || action.includes('z')) {
+                cube.rotate(
+                    /** @type {import('../src/core.js').Rotation} */ (action),
+                    (state) => {
+                        finalState = state;
+                    },
+                    () => {
+                        throw new Error('Rotation failed unexpectedly');
+                    },
+                );
+            } else {
+                cube.movement(
+                    /** @type {import('../src/core.js').Movement} */ (action),
+                    (state) => {
+                        finalState = state;
+                    },
+                    () => {
+                        throw new Error('Movement failed unexpectedly');
+                    },
+                );
+            }
+            drainUpdates(cube);
+        }
+
+        // Assert
+        expect(/** @type {string?} **/ (finalState)).toBe(toKociemba(cube._cubeInfo.initialStickerState));
+    });
+});

package/tests/setup.js

@@ -0,0 +1,36 @@
+import { JSDOM } from 'jsdom';
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+    url: 'http://localhost',
+});
+
+global.window = dom.window;
+global.document = dom.window.document;
+global.DOMParser = dom.window.DOMParser;
+global.XMLSerializer = dom.window.XMLSerializer;
+global.Node = dom.window.Node;
+global.window.HTMLCanvasElement.prototype.getContext = function () {
+    return {
+        fillRect: () => {},
+        clearRect: () => {},
+        getImageData: (x, y, w, h) => ({ data: new Uint8ClampedArray(w * h * 4) }),
+        setTransform: () => {},
+        drawImage: () => {},
+        save: () => {},
+        restore: () => {},
+        beginPath: () => {},
+        moveTo: () => {},
+        lineTo: () => {},
+        closePath: () => {},
+        stroke: () => {},
+        fill: () => {},
+        measureText: () => ({ width: 0 }),
+        _fillStyle: 'rgba(0,0,0,0)',
+        get fillStyle() {
+            return this._fillStyle;
+        },
+        set fillStyle(val) {
+            this._fillStyle = val;
+        },
+    };
+};

package/types/camera/cameraState.d.ts

@@ -0,0 +1,19 @@
+export class CameraState {
+    /**
+     * @param {boolean} up
+     * @param {boolean} right
+     */
+    constructor(up?: boolean, right?: boolean);
+    /** @type {boolean} */
+    Up: boolean;
+    /** @type {boolean} */
+    Right: boolean;
+    /**
+     * @param {import("../core").PeekType} peekType
+     */
+    peekCamera(peekType: import("../core").PeekType): void;
+    /**
+     * @returns {import("../core").PeekState}
+     */
+    toPeekState(): import("../core").PeekState;
+}

package/types/core.d.ts

@@ -0,0 +1,454 @@
+/**
+ * @typedef {typeof Movements.Single[keyof typeof Movements.Single]} SingleMove
+ * @typedef {typeof Movements.Wide[keyof typeof Movements.Wide]} WideMove
+ * @typedef {typeof Movements.Two[keyof typeof Movements.Two]} TwoMove
+ * @typedef {typeof Movements.Three[keyof typeof Movements.Three]} ThreeMove
+ * @typedef {typeof Movements.Four[keyof typeof Movements.Four]} FourMove
+ * @typedef {typeof Movements.Five[keyof typeof Movements.Five]} FiveMove
+ * @typedef {typeof Movements.Six[keyof typeof Movements.Six]} SixMove
+ * @typedef {SingleMove | WideMove | TwoMove | ThreeMove | FourMove | FiveMove | SixMove} Movement
+ */
+export const Movements: Readonly<{
+    Single: Readonly<{
+        R: "R";
+        R2: "R2";
+        RP: "R'";
+        L: "L";
+        L2: "L2";
+        LP: "L'";
+        U: "U";
+        U2: "U2";
+        UP: "U'";
+        D: "D";
+        D2: "D2";
+        DP: "D'";
+        F: "F";
+        F2: "F2";
+        FP: "F'";
+        B: "B";
+        B2: "B2";
+        BP: "B'";
+        M: "M";
+        M2: "M2";
+        MP: "M'";
+        E: "E";
+        E2: "E2";
+        EP: "E'";
+        S: "S";
+        S2: "S2";
+        SP: "S'";
+    }>;
+    Wide: Readonly<{
+        Rw: "Rw";
+        Rw2: "Rw2";
+        RwP: "Rw'";
+        r: "r";
+        r2: "r2";
+        rP: "r'";
+        Lw: "Lw";
+        Lw2: "Lw2";
+        LwP: "Lw'";
+        l: "l";
+        l2: "l2";
+        lP: "l'";
+        Fw: "Fw";
+        Fw2: "Fw2";
+        FwP: "Fw'";
+        f: "f";
+        f2: "f2";
+        fP: "f'";
+        Bw: "Bw";
+        Bw2: "Bw2";
+        BwP: "Bw'";
+        b: "b";
+        b2: "b2";
+        bP: "b'";
+        Uw: "Uw";
+        Uw2: "Uw2";
+        UwP: "Uw'";
+        u: "u";
+        u2: "u2";
+        uP: "u'";
+        Dw: "Dw";
+        Dw2: "D2";
+        DwP: "Dw'";
+        d: "d";
+        d2: "d2";
+        dP: "d'";
+    }>;
+    Two: Readonly<{
+        Rw: "2Rw";
+        Rw2: "2Rw2";
+        RwP: "2Rw'";
+        r: "2r";
+        r2: "2r2";
+        rP: "2r'";
+        R: "2R";
+        R2: "2R2";
+        RP: "2R'";
+        Lw: "2Lw";
+        Lw2: "2Lw2";
+        LwP: "2Lw'";
+        l: "2l";
+        l2: "2l2";
+        lP: "2l'";
+        L: "2L";
+        L2: "2L2";
+        LP: "2L'";
+        Fw: "2Fw";
+        Fw2: "2Fw2";
+        FwP: "2Fw'";
+        f: "2f";
+        f2: "2f2";
+        fP: "2f'";
+        F: "2F";
+        F2: "2F2";
+        FP: "2F'";
+        Bw: "2Bw";
+        Bw2: "2Bw2";
+        BwP: "2Bw'";
+        b: "2b";
+        b2: "2b2";
+        bP: "2b'";
+        B: "2B";
+        B2: "2B2";
+        BP: "2B'";
+        Uw: "2Uw";
+        Uw2: "2Uw2";
+        UwP: "2Uw'";
+        u: "2u";
+        u2: "2u2";
+        uP: "2u'";
+        U: "2U";
+        U2: "2U2";
+        UP: "2U'";
+        Dw: "2Dw";
+        Dw2: "2Dw2";
+        DwP: "2Dw'";
+        d: "2d";
+        d2: "2d2";
+        dP: "2d'";
+        D: "2D";
+        D2: "2D2";
+        DP: "2D'";
+    }>;
+    Three: Readonly<{
+        Rw: "3Rw";
+        Rw2: "3Rw2";
+        RwP: "3Rw'";
+        r: "3r";
+        r2: "3r2";
+        rP: "3r'";
+        R: "3R";
+        R2: "3R2";
+        RP: "3R'";
+        Lw: "3Lw";
+        Lw2: "3Lw2";
+        LwP: "3Lw'";
+        l: "3l";
+        l2: "3l2";
+        lP: "3l'";
+        L: "3L";
+        L2: "3L2";
+        LP: "3L'";
+        Fw: "3Fw";
+        Fw2: "3Fw2";
+        FwP: "3Fw'";
+        f: "3f";
+        f2: "3f2";
+        fP: "3f'";
+        F: "3F";
+        F2: "3F2";
+        FP: "3F'";
+        Bw: "3Bw";
+        Bw2: "3Bw2";
+        BwP: "3Bw'";
+        b: "3b";
+        b2: "3b2";
+        bP: "3b'";
+        B: "3B";
+        B2: "3B2";
+        BP: "3B'";
+        Uw: "3Uw";
+        Uw2: "3Uw2";
+        UwP: "3Uw'";
+        u: "3u";
+        u2: "3u2";
+        uP: "3u'";
+        U: "3U";
+        U2: "3U2";
+        UP: "3U'";
+        Dw: "3Dw";
+        Dw2: "3Dw2";
+        DwP: "3Dw'";
+        d: "3d";
+        d2: "3d2";
+        dP: "3d'";
+        D: "3D";
+        D2: "3D2";
+        DP: "3D'";
+    }>;
+    Four: Readonly<{
+        Rw: "4Rw";
+        Rw2: "4Rw2";
+        RwP: "4Rw'";
+        r: "4r";
+        r2: "4r2";
+        rP: "4r'";
+        R: "4R";
+        R2: "4R2";
+        RP: "4R'";
+        Lw: "4Lw";
+        Lw2: "4Lw2";
+        LwP: "4Lw'";
+        l: "4l";
+        l2: "4l2";
+        lP: "4l'";
+        L: "4L";
+        L2: "4L2";
+        LP: "4L'";
+        Fw: "4Fw";
+        Fw2: "4Fw2";
+        FwP: "4Fw'";
+        f: "4f";
+        f2: "4f2";
+        fP: "4f'";
+        F: "4F";
+        F2: "4F2";
+        FP: "4F'";
+        Bw: "4Bw";
+        Bw2: "4Bw2";
+        BwP: "4Bw'";
+        b: "4b";
+        b2: "4b2";
+        bP: "4b'";
+        B: "4B";
+        B2: "4B2";
+        BP: "4B'";
+        Uw: "4Uw";
+        Uw2: "4Uw2";
+        UwP: "4Uw'";
+        u: "4u";
+        u2: "4u2";
+        uP: "4u'";
+        U: "4U";
+        U2: "4U2";
+        UP: "4U'";
+        Dw: "4Dw";
+        Dw2: "4Dw2";
+        DwP: "4Dw'";
+        d: "4d";
+        d2: "4d2";
+        dP: "4d'";
+        D: "4D";
+        D2: "4D2";
+        DP: "4D'";
+    }>;
+    Five: Readonly<{
+        Rw: "5Rw";
+        Rw2: "5Rw2";
+        RwP: "5Rw'";
+        r: "5r";
+        r2: "5r2";
+        rP: "5r'";
+        R: "5R";
+        R2: "5R2";
+        RP: "5R'";
+        Lw: "5Lw";
+        Lw2: "5Lw2";
+        LwP: "5Lw'";
+        l: "5l";
+        l2: "5l2";
+        lP: "5l'";
+        L: "5L";
+        L2: "5L2";
+        LP: "5L'";
+        Fw: "5Fw";
+        Fw2: "5Fw2";
+        FwP: "5Fw'";
+        f: "5f";
+        f2: "5f2";
+        fP: "5f'";
+        F: "5F";
+        F2: "5F2";
+        FP: "5F'";
+        Bw: "5Bw";
+        Bw2: "5Bw2";
+        BwP: "5Bw'";
+        b: "5b";
+        b2: "5b2";
+        bP: "5b'";
+        B: "5B";
+        B2: "5B2";
+        BP: "5B'";
+        Uw: "5Uw";
+        Uw2: "5Uw2";
+        UwP: "5Uw'";
+        u: "5u";
+        u2: "5u2";
+        uP: "5u'";
+        U: "5U";
+        U2: "5U2";
+        UP: "5U'";
+        Dw: "5Dw";
+        Dw2: "5Dw2";
+        DwP: "5Dw'";
+        d: "5d";
+        d2: "5d2";
+        dP: "5d'";
+        D: "5D";
+        D2: "5D2";
+        DP: "5D'";
+    }>;
+    Six: Readonly<{
+        Rw: "6Rw";
+        Rw2: "6Rw2";
+        RwP: "6Rw'";
+        r: "6r";
+        r2: "6r2";
+        rP: "6r'";
+        R: "6R";
+        R2: "6R2";
+        RP: "6R'";
+        Lw: "6Lw";
+        Lw2: "6Lw2";
+        LwP: "6Lw'";
+        l: "6l";
+        l2: "6l2";
+        lP: "6l'";
+        L: "6L";
+        L2: "6L2";
+        LP: "6L'";
+        Fw: "6Fw";
+        Fw2: "6Fw2";
+        FwP: "6Fw'";
+        f: "6f";
+        f2: "6f2";
+        fP: "6f'";
+        F: "6F";
+        F2: "6F2";
+        FP: "6F'";
+        Bw: "6Bw";
+        Bw2: "6Bw2";
+        BwP: "6Bw'";
+        b: "6b";
+        b2: "6b2";
+        bP: "6b'";
+        B: "6B";
+        B2: "6B2";
+        BP: "6B'";
+        Uw: "6Uw";
+        Uw2: "6Uw2";
+        UwP: "6Uw'";
+        u: "6u";
+        u2: "6u2";
+        uP: "6u'";
+        U: "6U";
+        U2: "6U2";
+        UP: "6U'";
+        Dw: "6Dw";
+        Dw2: "6Dw2";
+        DwP: "6Dw'";
+        d: "6d";
+        d2: "6d2";
+        dP: "6d'";
+        D: "6D";
+        D2: "6D2";
+        DP: "6D'";
+    }>;
+}>;
+/**
+ * @typedef {typeof Rotations[keyof typeof Rotations]} Rotation
+ */
+export const Rotations: Readonly<{
+    x: "x";
+    x2: "x2";
+    xP: "x'";
+    y: "y";
+    y2: "y2";
+    yP: "y'";
+    z: "z";
+    z2: "z2";
+    zP: "z'";
+}>;
+/**
+ * @typedef {typeof Faces [keyof typeof Faces]} Face
+ */
+export const Faces: Readonly<{
+    U: "U";
+    D: "D";
+    L: "L";
+    R: "R";
+    F: "F";
+    B: "B";
+}>;
+/**
+ * @typedef {typeof CubeTypes [keyof typeof CubeTypes]} CubeType
+ */
+export const CubeTypes: Readonly<{
+    Two: "Two";
+    Three: "Three";
+    Four: "Four";
+    Five: "Five";
+    Six: "Six";
+    Seven: "Seven";
+}>;
+/**
+ * @typedef {typeof AnimationStyles[keyof typeof AnimationStyles]} AnimationStyle
+ */
+export const AnimationStyles: Readonly<{
+    Exponential: "exponential";
+    Next: "next";
+    Fixed: "fixed";
+    Match: "match";
+}>;
+/**
+ * @typedef {typeof FaceColours [keyof typeof FaceColours]} FaceColour
+ */
+export const FaceColours: Readonly<{
+    U: "white";
+    D: "yellow";
+    L: "#fc9a05";
+    R: "red";
+    F: "#2cbf13";
+    B: "blue";
+}>;
+/**
+ * @typedef {typeof PeekTypes [keyof typeof PeekTypes]} PeekType
+ */
+export const PeekTypes: Readonly<{
+    Horizontal: "horizontal";
+    Vertical: "vertical";
+    Right: "right";
+    Left: "left";
+    Up: "up";
+    Down: "down";
+    RightUp: "rightUp";
+    RightDown: "rightDown";
+    LeftUp: "leftUp";
+    LeftDown: "leftDown";
+}>;
+/**
+ * @typedef {typeof PeekStates [keyof typeof PeekStates]} PeekState
+ */
+export const PeekStates: Readonly<{
+    RightUp: "rightUp";
+    RightDown: "rightDown";
+    LeftUp: "leftUp";
+    LeftDown: "leftDown";
+}>;
+export type SingleMove = (typeof Movements.Single)[keyof typeof Movements.Single];
+export type WideMove = (typeof Movements.Wide)[keyof typeof Movements.Wide];
+export type TwoMove = (typeof Movements.Two)[keyof typeof Movements.Two];
+export type ThreeMove = (typeof Movements.Three)[keyof typeof Movements.Three];
+export type FourMove = (typeof Movements.Four)[keyof typeof Movements.Four];
+export type FiveMove = (typeof Movements.Five)[keyof typeof Movements.Five];
+export type SixMove = (typeof Movements.Six)[keyof typeof Movements.Six];
+export type Movement = SingleMove | WideMove | TwoMove | ThreeMove | FourMove | FiveMove | SixMove;
+export type Rotation = (typeof Rotations)[keyof typeof Rotations];
+export type Face = (typeof Faces)[keyof typeof Faces];
+export type CubeType = (typeof CubeTypes)[keyof typeof CubeTypes];
+export type AnimationStyle = (typeof AnimationStyles)[keyof typeof AnimationStyles];
+export type FaceColour = (typeof FaceColours)[keyof typeof FaceColours];
+export type PeekType = (typeof PeekTypes)[keyof typeof PeekTypes];
+export type PeekState = (typeof PeekStates)[keyof typeof PeekStates];

package/types/cube/animationSlice.d.ts

@@ -0,0 +1,26 @@
+/** @typedef {{axis: Axis, layers: number[], direction: number}} Slice */
+/**
+ * @param {import('../core').Movement } outerBlockMovement
+ * @param {import('../core').CubeType} cubeType
+ * @param {boolean} prioritiseStandardMovement
+ * @returns {Slice | undefined}
+ */
+export function GetLayerSlice(outerBlockMovement: import("../core").Movement, cubeType: import("../core").CubeType, prioritiseStandardMovement?: boolean): Slice | undefined;
+/**
+ * @param {import("../core").Rotation} rotation
+ * @param {import('../core').CubeType} cubeType
+ * @returns {Slice | undefined}
+ */
+export function GetRotationSlice(rotation: import("../core").Rotation, cubeType: import("../core").CubeType): Slice | undefined;
+/** @typedef {typeof Axi[keyof typeof Axi]} Axis */
+export const Axi: Readonly<{
+    x: "x";
+    y: "y";
+    z: "z";
+}>;
+export type Slice = {
+    axis: Axis;
+    layers: number[];
+    direction: number;
+};
+export type Axis = (typeof Axi)[keyof typeof Axi];

package/types/cube/animationState.d.ts

@@ -0,0 +1,41 @@
+/** @typedef {AnimationStatus[keyof AnimationStatus]} AnimationStatusType */
+export const AnimationStatus: Readonly<{
+    Pending: "pending";
+    Initialised: "initialised";
+    InProgress: "inProgress";
+    Complete: "complete";
+    Disposed: "disposed";
+}>;
+export class AnimationState {
+    /**
+     * @param {import('./animationSlice').Slice} slice
+     * @param {((state: string) => void )} completedCallback
+     * @param {((reason: string) => void )} failedCallback
+     */
+    constructor(slice: import("./animationSlice").Slice, completedCallback: ((state: string) => void), failedCallback: ((reason: string) => void));
+    /** @type {((state: string) => void )} */
+    completedCallback: ((state: string) => void);
+    /** @type {((reason: string) => void )} */
+    failedCallback: ((reason: string) => void);
+    /** @type {import('./animationSlice').Slice} */
+    slice: import("./animationSlice").Slice;
+    /** @type {AnimationStatusType} */
+    status: AnimationStatusType;
+    /** @type {number} */
+    timestampMs: number;
+    /** @type {number | undefined} */
+    _lastUpdatedTimeMs: number | undefined;
+    /** @type {number} */
+    _rotationPercentage: number;
+    initialise(): void;
+    /** @param {string} state */
+    complete(state: string): void;
+    /** @param {string} reason */
+    abort(reason: string): void;
+    /**
+     * @param {number} speedMs
+     * @returns {number} rotationIncrement
+     */
+    update(speedMs: number): number;
+}
+export type AnimationStatusType = "pending" | "initialised" | "inProgress" | "complete" | "disposed";