@houstonp/rubiks-cube 2.0.0 → 3.0.0

package/types/core/index.d.ts

@@ -0,0 +1,451 @@
+/**
+ * reverses the direction of a movement or rotation
+ * @template {Movement | Rotation} T
+ * @param {T} action
+ * @returns {T}
+ * */
+export function reverse<T extends Movement | Rotation>(action: T): T;
+/**
+ * Translates notation meant for a 3x3 into notation a big cube. This is so that 3x3 algorithms can be used on a big cube if desired. eg. for a 6x6 r -> 5r
+ * @template {Movement | Rotation} T
+ * @param {T} action
+ * @param {CubeType} cubeType
+ * @returns {T}
+ * */
+export function translate<T extends Movement | Rotation>(action: T, cubeType: CubeType): T;
+/**
+ *
+ * @param {string} rotation
+ */
+export function IsRotation(rotation: string): boolean;
+/**
+ *
+ * @param {string} movement
+ * @return {boolean}
+ */
+export function isMovement(movement: string): boolean;
+/**
+ * @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: "Dw2";
+        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'";
+    }>;
+    /**
+     * Build a layer-range move for big-cube notation. e.g. Movements.Range(2, 4, Movements.Wide.Rw) returns '2-4Rw',
+     * meaning "rotate layers 2 through 4 from the right face." Accepts wide moves (`Movements.Wide.*`), face
+     * moves (`Movements.Single.{R,L,U,D,F,B}` and modifiers), and slice moves (`Movements.Single.{M,E,S}` and
+     * modifiers). Already-prefixed moves (`2R`, `2-4Rw`) are rejected.
+     * @param {number} lower
+     * @param {number} upper
+     * @param {WideMove | SingleMove} baseMove
+     * @returns {Movement}
+     */
+    Range: (lower: number, upper: number, baseMove: WideMove | SingleMove) => Movement;
+}>;
+/**
+ * @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";
+}>;
+export const LayerCount: Readonly<{
+    Two: 2;
+    Three: 3;
+    Four: 4;
+    Five: 5;
+    Six: 6;
+    Seven: 7;
+}>;
+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];

package/types/rubiksCube/index.d.ts

@@ -0,0 +1,3 @@
+export { RubiksCubeController };
+export type AnimationOptions = import("./rubiksCubeController").AnimationOptions;
+import RubiksCubeController from './rubiksCubeController';

package/types/rubiksCube/rubiksCubeController.d.ts

@@ -0,0 +1,62 @@
+export default class RubiksCubeController {
+    /**
+     * @param {CubeType} cubeType
+     * @param {RubiksCubeViewInterface} view
+     * */
+    constructor(cubeType: CubeType, view: RubiksCubeViewInterface);
+    state: RubiksCubeState;
+    view: RubiksCubeViewInterface;
+    /**
+     * @param {Movement} movement
+     * @param {AnimationOptions} [options]
+     * @returns {Promise<string>}
+     */
+    movement(movement: Movement, options?: AnimationOptions): Promise<string>;
+    /**
+     * @param {Rotation} rotation
+     * @param {AnimationOptions} [options]
+     * @returns {Promise<string>}
+     */
+    rotation(rotation: Rotation, options?: AnimationOptions): Promise<string>;
+    /**
+     * @param {(Rotation | Movement)[]} actions
+     * @param {AnimationOptions} [options]
+     * @returns {string}
+     */
+    do(actions: (Rotation | Movement)[], options?: AnimationOptions): string;
+    /**
+     * @returns {string}
+     */
+    reset(): string;
+    /**
+     * @param {string} kociembaState
+     * @returns {boolean}
+     */
+    setState(kociembaState: string): boolean;
+    /**
+     * @returns {string}
+     */
+    getState(): string;
+    /**
+     * @param {CubeType} cubeType
+     * @returns {string}
+     */
+    setType(cubeType: CubeType): string;
+}
+export type AnimationOptions = {
+    translate?: boolean;
+    animationSpeedMs?: number;
+    reverse?: boolean;
+};
+export type RubiksCubeViewInterface = {
+    slice: (arg0: Slice, arg1: any | undefined) => Promise<void>;
+    setState: (arg0: StickerState) => void;
+    reset: () => void;
+    setType: (arg0: CubeType) => void;
+};
+import { RubiksCubeState } from '../state';
+import type { Movement } from '../core';
+import type { Rotation } from '../core';
+import type { CubeType } from '../core';
+import type { Slice } from '../state/slice';
+import type { StickerState } from '../state/stickerState';

package/types/rubiksCube3D/centerPiece.d.ts

@@ -0,0 +1,27 @@
+/** @import {Vector3Like} from 'three' */
+/** @typedef {{ positon: Vector3Like, rotation: Vector3Like }} CenterPieceUserData */
+export class CenterPiece extends Object3D<import("three").Object3DEventMap> {
+    constructor();
+    frontSticker: CenterSticker;
+    /** @type {Mesh<PlaneGeometry, MeshStandardMaterial> | null} */
+    logo: Mesh<PlaneGeometry, MeshStandardMaterial> | null;
+    get stickers(): CenterSticker[];
+    /**
+     * @param {string} logoPath
+     */
+    addLogo(logoPath: string): void;
+    removeLogo(): void;
+}
+export class CenterSticker extends Sticker {
+    constructor();
+}
+export type CenterPieceUserData = {
+    positon: Vector3Like;
+    rotation: Vector3Like;
+};
+import { Object3D } from 'three';
+import { Mesh } from 'three';
+import { PlaneGeometry } from 'three';
+import { MeshStandardMaterial } from 'three';
+import { Sticker } from './sticker';
+import type { Vector3Like } from 'three';

package/types/rubiksCube3D/cornerPiece.d.ts

@@ -0,0 +1,38 @@
+/** @import {Vector3Like} from 'three' */
+/** @import {Face} from "../core" */
+/** @typedef {{ positon: Vector3Like, rotation: Vector3Like }} CornerPieceUserData */
+/**
+ * @param {Material} frontMaterial
+ * @param {Material} rightMaterial
+ * @param {Material} topMaterial
+ * @param {Material} coreMaterial
+ * @returns {Group}
+ */
+export class CornerPiece extends Object3D<import("three").Object3DEventMap> {
+    constructor();
+    frontSticker: CornerSticker;
+    rightSticker: CornerSticker;
+    topSticker: CornerSticker;
+    get stickers(): CornerSticker[];
+    /**
+     * @param {Face} face
+     * @param {string} logoPath
+     */
+    addLogo(face: Face, logoPath: string): void;
+    logo: Mesh<PlaneGeometry, MeshStandardMaterial, import("three").Object3DEventMap>;
+    removeLogo(): void;
+}
+export class CornerSticker extends Sticker {
+    constructor();
+}
+export type CornerPieceUserData = {
+    positon: Vector3Like;
+    rotation: Vector3Like;
+};
+import { Object3D } from 'three';
+import type { Face } from "../core";
+import { PlaneGeometry } from 'three';
+import { MeshStandardMaterial } from 'three';
+import { Mesh } from 'three';
+import { Sticker } from './sticker';
+import type { Vector3Like } from 'three';

package/types/rubiksCube3D/cubeConfig.d.ts

@@ -0,0 +1,32 @@
+/** @import {CubeType, Face} from '../core' */
+/** @import {ColorRepresentation} from 'three' */
+/**
+ * @typedef CubeConfig
+ * @property {number[]} layers
+ * @property {number} pieceSize
+ * @property {number} coreSize
+ * @property {number} outerLayerMultiplier
+ */
+/**
+ * @param {CubeType} cubeType
+ * @return {CubeConfig}
+ */
+export function getCubeConfig(cubeType: CubeType): CubeConfig;
+export namespace FaceColors {
+    let B: string;
+    let D: string;
+    let F: string;
+    let L: string;
+    let R: string;
+    let U: string;
+}
+export function ColorToFace(color: ColorRepresentation): Face;
+export type CubeConfig = {
+    layers: number[];
+    pieceSize: number;
+    coreSize: number;
+    outerLayerMultiplier: number;
+};
+import type { CubeType } from '../core';
+import type { ColorRepresentation } from 'three';
+import type { Face } from '../core';

package/types/rubiksCube3D/cubeSettings.d.ts

@@ -0,0 +1,33 @@
+/** @import {CubeType} from '../core' */
+/**
+ * @typedef RubiksCube3DSettingsOptions
+ * @property {CubeType} [cubeType]
+ * @property {number} [pieceGap]
+ * @property {number} [animationSpeedMs]
+ * @property {gsap.EaseString | gsap.EaseFunction} [animationStyle]
+ * @property {string | null} [logo]
+ */
+export default class RubiksCube3DSettings {
+    /**
+     * @param {RubiksCube3DSettingsOptions} [options]
+     */
+    constructor(options?: RubiksCube3DSettingsOptions);
+    /** @type {CubeType} */
+    cubeType: CubeType;
+    /** @type {number} */
+    pieceGap: number;
+    /** @type {number} */
+    animationSpeedMs: number;
+    /** @type {gsap.EaseString | gsap.EaseFunction} */
+    animationStyle: gsap.EaseString | gsap.EaseFunction;
+    /** @type {string | null} */
+    logo: string | null;
+}
+export type RubiksCube3DSettingsOptions = {
+    cubeType?: CubeType;
+    pieceGap?: number;
+    animationSpeedMs?: number;
+    animationStyle?: gsap.EaseString | gsap.EaseFunction;
+    logo?: string | null;
+};
+import type { CubeType } from '../core';

package/types/rubiksCube3D/edgePiece.d.ts

@@ -0,0 +1,18 @@
+/** @import {Vector3Like} from 'three' */
+/** @typedef {{ positon: Vector3Like, rotation: Vector3Like }} EdgePieceUserData*/
+export class EdgePiece extends Object3D<import("three").Object3DEventMap> {
+    constructor();
+    frontSticker: EdgeSticker;
+    topSticker: EdgeSticker;
+    get stickers(): EdgeSticker[];
+}
+export class EdgeSticker extends Sticker {
+    constructor();
+}
+export type EdgePieceUserData = {
+    positon: Vector3Like;
+    rotation: Vector3Like;
+};
+import { Object3D } from 'three';
+import { Sticker } from './sticker';
+import type { Vector3Like } from 'three';

package/types/rubiksCube3D/index.d.ts

@@ -0,0 +1,3 @@
+import RubiksCube3D from './rubiksCube3D';
+import RubiksCube3DSettings from './cubeSettings';
+export { RubiksCube3D, RubiksCube3DSettings };