@houstonp/rubiks-cube 2.1.0 → 3.0.0

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/{three → rubiksCube3D}/edgePiece.d.ts

@@ -1,4 +1,5 @@
-/** @typedef {{ positon: import('three').Vector3Like, rotation: import('three').Vector3Like }} EdgePieceUserData*/
+/** @import {Vector3Like} from 'three' */
+/** @typedef {{ positon: Vector3Like, rotation: Vector3Like }} EdgePieceUserData*/
 export class EdgePiece extends Object3D<import("three").Object3DEventMap> {
     constructor();
     frontSticker: EdgeSticker;
@@ -9,8 +10,9 @@ export class EdgeSticker extends Sticker {
     constructor();
 }
 export type EdgePieceUserData = {
-    positon: import("three").Vector3Like;
-    rotation: import("three").Vector3Like;
+    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 };

package/types/rubiksCube3D/rubiksCube3D.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @implements {RubiksCubeViewInterface}
+ */
+export default class RubiksCube3D extends Object3D<import("three").Object3DEventMap> implements RubiksCubeViewInterface {
+    /**
+     * @public
+     * @param {RubiksCube3DSettings} cubeSettings
+     */
+    constructor(cubeSettings: RubiksCube3DSettings);
+    /** @type {RubiksCube3DSettings} */
+    _cubeSettings: RubiksCube3DSettings;
+    /** @type {number} */
+    _pieceGap: number;
+    /** @type {CubeType} */
+    _cubeType: CubeType;
+    /** @type {CubeConfig} */
+    _cubeConfig: CubeConfig;
+    /** @type {Group} */
+    _mainGroup: Group;
+    /** @type {Group} */
+    _animationGroup: Group;
+    /** @type {GSAPAnimation | undefined} */
+    _currentAnimation: GSAPAnimation | undefined;
+    /**
+     * Creates the main group containing all the pieces of the cube in their default position and rotation. Should only be called once during initialization.
+     * @private
+     **/
+    private createCubeGroup;
+    /**
+     * @param {Group} group
+     * @returns {(CornerPiece | EdgePiece | CenterPiece)[]}
+     */
+    _getPieces(group?: Group): (CornerPiece | EdgePiece | CenterPiece)[];
+    /**
+     * Returns the sticker state of the cube. Can only be called when an Animation is not in progress as not all pieces would be in the main group.
+     * @returns {StickerState}
+     */
+    getStickerState(): StickerState;
+    /**
+     * Sets the sticker state of the cube. Can only be called when an Animation is not in progress as not all pieces would be in the main group.
+     * @private
+     * @param {StickerState} stickerState
+     */
+    private setStickerState;
+    /**
+     *
+     * @param {string} logo
+     */
+    addLogo(logo: string): void;
+    /**
+     * Returns the pieces that should be rotated for a given slice. If the slice has no layers, all pieces will be returned. Should only be called before an Animation is started.
+     * @private
+     * @param {Slice} slice
+     * @returns {Object3D[]}
+     */
+    private getRotationLayer;
+    /**
+     * Updates the gap of the pieces. To be used when the cube is not rotating
+     * @private
+     * @param {number} pieceGap
+     * @returns {void}
+     */
+    private updateGap;
+    /**
+     * Adds pieces in the rotationGroup back into the main group.
+     * Updates the position and rotation of the pieces according to their world position and rotation, then resets the rotation of the rotation group.
+     * Should only be called when a rotation is in progress.
+     * @private
+     * @returns {void}
+     */
+    private clearAnimationGroup;
+    /**
+     * @private
+     * @param {Slice} slice
+     */
+    private fillAnimationGroup;
+    /**
+     * @public
+     * @param {number} animationSpeedMs
+     */
+    public setCurrentAnimationSpeed(animationSpeedMs: number): void;
+    /**
+     * @public
+     */
+    public reset(): void;
+    /**
+     * @public
+     * @param {StickerState} stickerState
+     */
+    public setState(stickerState: StickerState): void;
+    /**
+     * sets the state of the cube
+     * @public
+     * @param {CubeType} cubeType
+     * @returns {void}
+     */
+    public setType(cubeType: CubeType): void;
+    /**
+     * @public
+     * @param {Slice} slice
+     * @param {{animationSpeedMs: number?, ease: gsap.EaseString | gsap.EaseFunction | undefined}} [options]
+     * @returns {Promise<void>}
+     */
+    public slice(slice: Slice, options?: {
+        animationSpeedMs: number | null;
+        ease: gsap.EaseString | gsap.EaseFunction | undefined;
+    }): Promise<void>;
+}
+export type RubiksCubeViewInterface = _RubiksCubeViewInterface;
+import { Object3D } from 'three';
+import RubiksCube3DSettings from './cubeSettings';
+import type { CubeType } from '../core';
+import type { CubeConfig } from './cubeConfig';
+import { Group } from 'three';
+import { CornerPiece } from './cornerPiece';
+import { EdgePiece } from './edgePiece';
+import { CenterPiece } from './centerPiece';
+import type { StickerState } from '../state/stickerState';
+import type { Slice } from '../state/slice';
+import type { RubiksCubeViewInterface as _RubiksCubeViewInterface } from '../rubiksCube/rubiksCubeController';

package/types/rubiksCube3D/sticker.d.ts

@@ -0,0 +1,18 @@
+/** @import {BufferGeometry, ColorRepresentation} from 'three' */
+export class Sticker extends Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+    /**
+     * @param {BufferGeometry} geometry
+     */
+    constructor(geometry: BufferGeometry);
+    /**
+     * @param {ColorRepresentation} color
+     */
+    set color(color: ColorRepresentation);
+    /**
+     * @returns {ColorRepresentation} color
+     */
+    get color(): ColorRepresentation;
+}
+import type { BufferGeometry } from 'three';
+import { Mesh } from 'three';
+import type { ColorRepresentation } from 'three';

package/types/state/index.d.ts

@@ -0,0 +1,5 @@
+import { RubiksCubeState } from './rubiksCubeState';
+import { Axi } from './slice';
+import { GetMovementSlice } from './slice';
+import { GetRotationSlice } from './slice';
+export { RubiksCubeState, Axi, GetMovementSlice, GetRotationSlice };

package/types/state/rubiksCubeState.d.ts

@@ -0,0 +1,108 @@
+export class RubiksCubeState {
+    /**
+     *
+     * @param {CubeType} cubeType
+     */
+    constructor(cubeType: CubeType);
+    cubeType: CubeType;
+    /** @type {StickerState?} */
+    stickerState: StickerState | null;
+    /** @type {number[]} */
+    layers: number[];
+    /** @type {pieceState[]} */
+    corners: pieceState[];
+    /** @type {pieceState[]} */
+    edges: pieceState[];
+    /** @type {pieceState[]} */
+    centers: pieceState[];
+    reset(): void;
+    /**
+     * @param {StickerState} stickerState
+     * @returns {void}
+     */
+    setState(stickerState: StickerState): void;
+    /**
+     * @return {StickerState}
+     */
+    getState(): StickerState;
+    /**
+     * @returns {string}
+     */
+    getKociemba(): string;
+    /**
+     * @param {string} kociembaString
+     * @returns {boolean}
+     */
+    setKociemba(kociembaString: string): boolean;
+    /**
+     *
+     * @param {Slice} slice
+     */
+    slice(slice: Slice): void;
+    /**
+     * @param {Movement} movement
+     * @param {MoveOptions} [options]
+     * @returns {Slice?}
+     */
+    move(movement: Movement, options?: MoveOptions): Slice | null;
+    /**
+     * @param {Rotation} rotation
+     * @param {RotationOptions} [options]
+     * @returns {Slice?}
+     */
+    rotate(rotation: Rotation, options?: RotationOptions): Slice | null;
+    /**
+     * @param {(Rotation | Movement)[]} actions
+     * @param {MoveOptions | RotationOptions } [options]
+     */
+    do(actions: (Rotation | Movement)[], options?: MoveOptions | RotationOptions): void;
+    /**
+     * @private
+     * @param {number} position
+     * @returns {number}
+     */
+    private _getLayerNumber;
+}
+export function corners(layers: number[]): {
+    position: vector;
+    rotation: vector;
+}[];
+export function centers(layers: number[]): {
+    position: vector;
+    rotation: vector;
+}[];
+export function edges(layers: number[]): {
+    position: vector;
+    rotation: vector;
+}[];
+export type state = {
+    corners: pieceState[];
+    edges: pieceState[];
+    centers: pieceState[];
+};
+export type pieceState = {
+    position: vector;
+    rotation: vector;
+    stickers: {
+        face: Face;
+        direction: vector;
+    }[];
+};
+export type vector = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type MoveOptions = {
+    translate?: boolean | undefined;
+    reverse?: boolean | undefined;
+};
+export type RotationOptions = {
+    reverse?: boolean | undefined;
+};
+import type { CubeType } from '../core';
+import type { StickerState } from './stickerState';
+import type { Slice } from './slice';
+import type { Movement } from '../core';
+import type { Rotation } from '../core';
+import type { Face } from '../core';

package/types/state/slice.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A slice represents an action or movement of a 3D rubiks cube. layers
+ * @typedef  Slice
+ * @property {Axis} axis the axis that pieces rotate around
+ * @property {number[]} layerIds starting from 0 to the size of the cube. Layers represent what layers are included in the movement.
+ * @property {number} direction the direction and magnitude of the rotation
+ **/
+/**
+ * @param {Movement} movement
+ * @param {number} layerCount
+ * @returns {Slice | undefined}
+ */
+export function GetMovementSlice(movement: Movement, layerCount: number): Slice | undefined;
+/**
+ * @param {Rotation} rotation
+ * @param {number} layerCount
+ * @returns {Slice | undefined}
+ */
+export function GetRotationSlice(rotation: Rotation, layerCount: number): Slice | undefined;
+/** @import {Movement, Rotation} from '../core' */
+/** @typedef {typeof Axi[keyof typeof Axi]} Axis */
+export const Axi: Readonly<{
+    x: "x";
+    y: "y";
+    z: "z";
+}>;
+/**
+ * A slice represents an action or movement of a 3D rubiks cube. layers
+ */
+export type Slice = {
+    /**
+     * the axis that pieces rotate around
+     */
+    axis: Axis;
+    /**
+     * starting from 0 to the size of the cube. Layers represent what layers are included in the movement.
+     */
+    layerIds: number[];
+    /**
+     * the direction and magnitude of the rotation
+     */
+    direction: number;
+};
+export type Axis = (typeof Axi)[keyof typeof Axi];
+import type { Movement } from '../core';
+import type { Rotation } from '../core';

package/types/state/stickerState.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @param {vector} stickerDirection
+ * @param {vector} piecePosition
+ * @param {number[]} layers
+ * @returns {{face: Face, i: number, j: number}}
+ */
+export function getStickerFaceIndex(stickerDirection: vector, piecePosition: vector, layers: number[]): {
+    face: Face;
+    i: number;
+    j: number;
+};
+/**
+ * @param {StickerState} stickerState
+ * @returns {string}
+ */
+export function toKociemba(stickerState: StickerState): string;
+/**
+ * @param {string} kociembaString
+ * @returns {StickerState | undefined} stickerState
+ */
+export function fromKociemba(kociembaString: string): StickerState | undefined;
+export function defaultStickerState(cubeType: CubeType): StickerState;
+export function getEmptyStickerState(cubeType: CubeType): StickerState;
+export type StickerState = {
+    U: Face[][];
+    D: Face[][];
+    F: Face[][];
+    B: Face[][];
+    L: Face[][];
+    R: Face[][];
+};
+import type { vector } from './rubiksCubeState';
+import type { Face } from '../core';
+import type { CubeType } from '../core';

package/types/webComponent/cameraState.d.ts

@@ -0,0 +1,22 @@
+/** @import {PeekAction, PeekState} from './constants' */
+export class CameraState {
+    /**
+     * @param {boolean} up
+     * @param {boolean} right
+     */
+    constructor(up?: boolean, right?: boolean);
+    /** @type {boolean} */
+    Up: boolean;
+    /** @type {boolean} */
+    Right: boolean;
+    /**
+     * @param {PeekAction} action
+     */
+    peekCamera(action: PeekAction): void;
+    /**
+     * @returns {PeekState}
+     */
+    toPeekState(): PeekState;
+}
+import type { PeekAction } from './constants';
+import type { PeekState } from './constants';

package/types/webComponent/constants.d.ts

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

package/types/webComponent/index.d.ts

@@ -0,0 +1,6 @@
+export { RubiksCubeElement } from "./rubiksCubeElement";
+export type PeekState = import("./constants").PeekState;
+export type PeekAction = import("./constants").PeekAction;
+export type CameraOptions = import("./constants").CameraOptions;
+export type AnimationStyle = import("./constants").AnimationStyle;
+export { AttributeNames, PeekStates, PeekActions, AnimationStyles } from "./constants";