@houstonp/rubiks-cube 2.0.0 → 3.0.0

package/src/state/rubiksCubeState.js

@@ -0,0 +1,471 @@
+/// @ts-check
+import { Euler, Quaternion, Vector3 } from 'three';
+import { CubeTypes, Faces, isMovement, IsRotation, Movements, reverse, translate } from '../core';
+import { Axi, GetMovementSlice, GetRotationSlice } from './slice';
+import { defaultStickerState, fromKociemba, getEmptyStickerState, getStickerFaceIndex, toKociemba } from './stickerState';
+/** @import {StickerState} from './stickerState' */
+/** @import {Rotation, CubeType, Movement, Face} from '../core' */
+/** @import {Slice} from './slice' */
+
+/**
+ *  @typedef {{corners: pieceState[], edges: pieceState[], centers: pieceState[]}} state
+ */
+
+/**
+ * @typedef {{position: vector, rotation: vector, stickers: {face: Face, direction: vector}[]}} pieceState
+ */
+
+/**
+ * @typedef {{x: number,y: number,z: number}} vector
+ */
+
+/**
+ *  @typedef {{translate?: boolean | undefined, reverse?: boolean | undefined}} MoveOptions
+ */
+
+/**
+ *  @typedef {{reverse?: boolean | undefined}} RotationOptions
+ */
+
+const Layers = {
+    [CubeTypes.Two]: [-1, 1],
+    [CubeTypes.Three]: [-1, 0, 1],
+    [CubeTypes.Four]: [-2, -1, 1, 2],
+    [CubeTypes.Five]: [-2, -1, 0, 1, 2],
+    [CubeTypes.Six]: [-3, -2, -1, 1, 2, 3],
+    [CubeTypes.Seven]: [-3, -2, -1, 0, 1, 2, 3],
+};
+
+const ERROR_MARGIN = 0.0001;
+export class RubiksCubeState {
+    /**
+     *
+     * @param {CubeType} cubeType
+     */
+    constructor(cubeType) {
+        this.cubeType = cubeType;
+        /** @type {StickerState?} */
+        this.stickerState = null;
+        /** @type {number[]} */
+        this.layers = Layers[cubeType];
+        /** @type {pieceState[]} */
+        this.corners = corners(this.layers).map((corner) => {
+            return {
+                position: corner.position,
+                rotation: corner.rotation,
+                stickers: [
+                    { face: Faces.U, direction: { x: 0, y: 0, z: 1 } },
+                    { face: Faces.U, direction: { x: 0, y: 1, z: 0 } },
+                    { face: Faces.U, direction: { x: 1, y: 0, z: 0 } },
+                ],
+            };
+        });
+        /** @type {pieceState[]} */
+        this.edges = edges(this.layers).map((edge) => {
+            return {
+                position: edge.position,
+                rotation: edge.rotation,
+                stickers: [
+                    { face: Faces.U, direction: { x: 0, y: 0, z: 1 } },
+                    { face: Faces.U, direction: { x: 0, y: 1, z: 0 } },
+                ],
+            };
+        });
+        /** @type {pieceState[]} */
+        this.centers = centers(this.layers).map((center) => {
+            return {
+                position: center.position,
+                rotation: center.rotation,
+                stickers: [{ face: Faces.U, direction: { x: 0, y: 0, z: 1 } }],
+            };
+        });
+        /** @type {StickerState?} */
+        this.stickerState = null;
+        this.setState(defaultStickerState(cubeType));
+    }
+
+    reset() {
+        this.stickerState = null;
+        this.setState(defaultStickerState(this.cubeType));
+    }
+
+    /**
+     * @param {StickerState} stickerState
+     * @returns {void}
+     */
+    setState(stickerState) {
+        this.stickerState = stickerState;
+        [...this.corners, ...this.edges, ...this.centers].forEach((piece) => {
+            piece.stickers.forEach((sticker) => {
+                const stickerPosition = new Vector3(sticker.direction.x, sticker.direction.y, sticker.direction.z);
+                stickerPosition.applyEuler(new Euler(piece.rotation.x, piece.rotation.y, piece.rotation.z));
+                stickerPosition.round();
+                const { face, i, j } = getStickerFaceIndex(stickerPosition, piece.position, this.layers);
+                sticker.face = stickerState[face][i][j];
+            });
+        });
+    }
+
+    /**
+     * @return {StickerState}
+     */
+    getState() {
+        if (this.stickerState) {
+            return this.stickerState;
+        }
+        const stickerState = getEmptyStickerState(this.cubeType);
+        [...this.corners, ...this.edges, ...this.centers].forEach((piece) => {
+            piece.stickers.forEach((sticker) => {
+                const stickerPosition = new Vector3(sticker.direction.x, sticker.direction.y, sticker.direction.z);
+                stickerPosition.applyEuler(new Euler(piece.rotation.x, piece.rotation.y, piece.rotation.z));
+                stickerPosition.round();
+                const { face, i, j } = getStickerFaceIndex(stickerPosition, piece.position, this.layers);
+                stickerState[face][i][j] = sticker.face;
+            });
+        });
+        this.stickerState = stickerState;
+        return this.stickerState;
+    }
+
+    /**
+     * @returns {string}
+     */
+    getKociemba() {
+        return toKociemba(this.getState());
+    }
+
+    /**
+     * @param {string} kociembaString
+     * @returns {boolean}
+     */
+    setKociemba(kociembaString) {
+        const stickerState = fromKociemba(kociembaString);
+        if (stickerState == null) {
+            return false;
+        }
+        this.setState(stickerState);
+        return true;
+    }
+
+    /**
+     *
+     * @param {Slice} slice
+     */
+    slice(slice) {
+        [...this.corners, ...this.edges, ...this.centers]
+            .filter((piece) => {
+                switch (slice.axis) {
+                    case Axi.x:
+                        return slice.layerIds.map((id) => this.layers[id]).some((layer) => Math.abs(layer - piece.position.x) < ERROR_MARGIN);
+                    case Axi.y:
+                        return slice.layerIds.map((id) => this.layers[id]).some((layer) => Math.abs(layer - piece.position.y) < ERROR_MARGIN);
+                    case Axi.z:
+                        return slice.layerIds.map((id) => this.layers[id]).some((layer) => Math.abs(layer - piece.position.z) < ERROR_MARGIN);
+                }
+            })
+            .forEach((piece) => {
+                const position = new Vector3(piece.position.x, piece.position.y, piece.position.z);
+                const rotation = new Quaternion().setFromEuler(new Euler(piece.rotation.x, piece.rotation.y, piece.rotation.z));
+                const rotationAxis = new Vector3(
+                    slice.axis === Axi.x ? slice.direction : 0,
+                    slice.axis === Axi.y ? slice.direction : 0,
+                    slice.axis === Axi.z ? slice.direction : 0,
+                ).normalize();
+
+                const angle = (Math.abs(slice.direction) * Math.PI) / 2;
+
+                // Apply rotation
+                const rotationQuat = new Quaternion();
+                rotationQuat.setFromAxisAngle(rotationAxis, angle);
+                position.applyQuaternion(rotationQuat);
+                rotation.premultiply(rotationQuat);
+
+                // Update piece position
+                piece.position.x = this.layers[this._getLayerNumber(position.x)];
+                piece.position.y = this.layers[this._getLayerNumber(position.y)];
+                piece.position.z = this.layers[this._getLayerNumber(position.z)];
+
+                // Update rotation using quaternion multiplication
+                const newRotation = new Euler().setFromQuaternion(rotation);
+                piece.rotation.x = newRotation.x;
+                piece.rotation.y = newRotation.y;
+                piece.rotation.z = newRotation.z;
+            });
+        this.stickerState = null;
+    }
+
+    /**
+     * @param {Movement} movement
+     * @param {MoveOptions} [options]
+     * @returns {Slice?}
+     */
+    move(movement, options) {
+        let action = movement;
+        if (options?.reverse) {
+            action = reverse(movement);
+        }
+        if (options?.translate) {
+            action = translate(movement, this.cubeType);
+        }
+        const slice = GetMovementSlice(movement, this.layers.length);
+        if (slice == null) {
+            console.error(`Failed to get movement slice. Invalid movement: [${movement}]`);
+            return null;
+        }
+        this.slice(slice);
+        return slice;
+    }
+
+    /**
+     * @param {Rotation} rotation
+     * @param {RotationOptions} [options]
+     * @returns {Slice?}
+     */
+    rotate(rotation, options) {
+        let action = rotation;
+        if (options?.reverse) {
+            action = reverse(rotation);
+        }
+        const slice = GetRotationSlice(action, this.layers.length);
+        if (slice == null) {
+            console.error(`Failed to get rotation slice. invalid rotation: [${action}]`);
+            return null;
+        }
+        this.slice(slice);
+        return slice;
+    }
+
+    /**
+     * @param {(Rotation | Movement)[]} actions
+     * @param {MoveOptions | RotationOptions } [options]
+     */
+    do(actions, options) {
+        actions.forEach((action) => {
+            if (isMovement(action)) {
+                this.move(/** @type {Movement} */ (action), options);
+            } else if (IsRotation(action)) {
+                this.rotate(/** @type  {Rotation} */ (action), options);
+            } else {
+                console.error(`Invalid Notation: ${action}`);
+            }
+        });
+    }
+
+    /**
+     * @private
+     * @param {number} position
+     * @returns {number}
+     */
+    _getLayerNumber(position) {
+        for (let i = 0; i < this.layers.length; i++) {
+            if (Math.abs(position - this.layers[i]) < ERROR_MARGIN) {
+                return i;
+            }
+        }
+        throw new Error(`Failed to get layer number. position ${position} not found in layers ${this.layers}`);
+    }
+}
+
+/**
+ * @param {number[]} layers
+ * @return {{position: vector, rotation: vector}[]}
+ */
+export const corners = (layers) => {
+    const lastLayer = layers[layers.length - 1];
+    const firstLayer = layers[0];
+    return [
+        {
+            position: { x: lastLayer, y: lastLayer, z: lastLayer },
+            rotation: { x: 0, y: 0, z: 0 },
+        },
+        {
+            position: { x: lastLayer, y: lastLayer, z: firstLayer },
+            rotation: { x: 0, y: Math.PI / 2, z: 0 },
+        },
+        {
+            position: { x: lastLayer, y: firstLayer, z: lastLayer },
+            rotation: { x: 0, y: Math.PI / 2, z: Math.PI },
+        },
+        {
+            position: { x: lastLayer, y: firstLayer, z: firstLayer },
+            rotation: { x: 0, y: Math.PI, z: Math.PI },
+        },
+        {
+            position: { x: firstLayer, y: lastLayer, z: lastLayer },
+            rotation: { x: 0, y: -Math.PI / 2, z: 0 },
+        },
+        {
+            position: { x: firstLayer, y: lastLayer, z: firstLayer },
+            rotation: { x: 0, y: Math.PI, z: 0 },
+        },
+        {
+            position: { x: firstLayer, y: firstLayer, z: lastLayer },
+            rotation: { x: 0, y: 0, z: Math.PI },
+        },
+        {
+            position: { x: firstLayer, y: firstLayer, z: firstLayer },
+            rotation: { x: 0, y: -Math.PI / 2, z: Math.PI },
+        },
+    ];
+};
+
+/**
+ * @param {number[]} layers
+ * @return {{position: vector, rotation: vector}[]}
+ */
+export const centers = (layers) => {
+    const lastLayer = layers[layers.length - 1];
+    const firstLayer = layers[0];
+    const innerLayers = layers.slice(1, -1);
+    return [
+        //right
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: lastLayer, y: layer1, z: layer2 },
+                    rotation: { x: 0, y: Math.PI / 2, z: 0 },
+                };
+            }),
+        ),
+        //up
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: layer1, y: lastLayer, z: layer2 },
+                    rotation: { x: -Math.PI / 2, y: 0, z: 0 },
+                };
+            }),
+        ),
+        //front
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: layer1, y: layer2, z: lastLayer },
+                    rotation: { x: 0, y: 0, z: 0 },
+                };
+            }),
+        ),
+        //back
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: layer1, y: layer2, z: firstLayer },
+                    rotation: { x: 0, y: Math.PI, z: 0 },
+                };
+            }),
+        ),
+        //down
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: layer1, y: firstLayer, z: layer2 },
+                    rotation: { x: Math.PI / 2, y: 0, z: 0 },
+                };
+            }),
+        ),
+        //left
+        ...innerLayers.flatMap((layer1) =>
+            innerLayers.map((layer2) => {
+                return {
+                    position: { x: firstLayer, y: layer1, z: layer2 },
+                    rotation: { x: 0, y: -Math.PI / 2, z: 0 },
+                };
+            }),
+        ),
+    ];
+};
+
+/**
+ * @param {number[]} layers
+ * @return {{position: vector, rotation: vector}[]}
+ */
+export const edges = (layers) => {
+    const lastLayer = layers[layers.length - 1];
+    const firstLayer = layers[0];
+    return [
+        // RU
+        ...layers.map((layer) => {
+            return {
+                position: { x: lastLayer, y: lastLayer, z: layer },
+                rotation: { x: 0, y: Math.PI / 2, z: 0 },
+            };
+        }),
+        // RF
+        ...layers.map((layer) => {
+            return {
+                position: { x: lastLayer, y: layer, z: lastLayer },
+                rotation: { x: 0, y: 0, z: -Math.PI / 2 },
+            };
+        }),
+        // RB
+        ...layers.map((layer) => {
+            return {
+                position: { x: lastLayer, y: layer, z: firstLayer },
+                rotation: { x: 0, y: Math.PI / 2, z: -Math.PI / 2 },
+            };
+        }),
+        // RD
+        ...layers.map((layer) => {
+            return {
+                position: { x: lastLayer, y: firstLayer, z: layer },
+                rotation: { x: Math.PI, y: Math.PI / 2, z: 0 },
+            };
+        }),
+        // UF
+        ...layers.map((layer) => {
+            return {
+                position: { x: layer, y: lastLayer, z: lastLayer },
+                rotation: { x: 0, y: 0, z: 0 },
+            };
+        }),
+        // UB
+        ...layers.map((layer) => {
+            return {
+                position: { x: layer, y: lastLayer, z: firstLayer },
+                rotation: { x: -Math.PI / 2, y: 0, z: 0 },
+            };
+        }),
+        // DF
+        ...layers.map((layer) => {
+            return {
+                position: { x: layer, y: firstLayer, z: lastLayer },
+                rotation: { x: Math.PI / 2, y: 0, z: 0 },
+            };
+        }),
+        // DB
+        ...layers.map((layer) => {
+            return {
+                position: { x: layer, y: firstLayer, z: firstLayer },
+                rotation: { x: Math.PI, y: 0, z: 0 },
+            };
+        }),
+        // LU
+        ...layers.map((layer) => {
+            return {
+                position: { x: firstLayer, y: lastLayer, z: layer },
+                rotation: { x: 0, y: -Math.PI / 2, z: 0 },
+            };
+        }),
+        // LF
+        ...layers.map((layer) => {
+            return {
+                position: { x: firstLayer, y: layer, z: lastLayer },
+                rotation: { x: 0, y: 0, z: Math.PI / 2 },
+            };
+        }),
+        // LB
+        ...layers.map((layer) => {
+            return {
+                position: { x: firstLayer, y: layer, z: firstLayer },
+                rotation: { x: 0, y: -Math.PI / 2, z: Math.PI / 2 },
+            };
+        }),
+        // LD
+        ...layers.map((layer) => {
+            return {
+                position: { x: firstLayer, y: firstLayer, z: layer },
+                rotation: { x: 0, y: -Math.PI / 2, z: Math.PI },
+            };
+        }),
+    ];
+};

package/src/state/slice.js

@@ -0,0 +1,236 @@
+// @ts-check
+import { Rotations } from '../core';
+/** @import {Movement, Rotation} from '../core' */
+
+/** @typedef {typeof Axi[keyof typeof Axi]} Axis */
+export const Axi = Object.freeze({
+    x: 'x',
+    y: 'y',
+    z: 'z',
+});
+
+/**
+ * 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, layerCount) {
+    const result = RegExp(`^([1234567]|[123456]-[1234567])?([RLUDFB]w|[RLUDFBMES]|[rludfbmes])([123])?(\')?$`).exec(movement);
+    if (result == null) {
+        console.error(`Failed to parse movement. Invalid movement: ${movement}`);
+        return undefined;
+    }
+    /** @type {number | undefined} */
+    let layerRangeLower = undefined;
+    /** @type {number | undefined} */
+    let layerRangeUpper = undefined;
+    /** @type {number | undefined} */
+    let layerNumber = undefined;
+    if (result[1]?.includes('-')) {
+        layerRangeLower = parseInt(result[1][0]);
+        layerRangeUpper = parseInt(result[1][2]);
+    } else {
+        layerNumber = result[1] ? parseInt(result[1]) : undefined;
+    }
+
+    if (layerRangeLower != null && layerRangeUpper != null) {
+        if (layerRangeLower >= layerRangeUpper || layerRangeUpper > layerCount || layerRangeLower > layerCount - 1) {
+            console.error(`${movement} is not valid for the current cubeType. For range inputs like x-yr it should follow that 1 <= x < y <= ${layerCount}.`);
+            return undefined;
+        }
+    }
+    if (layerNumber != null && layerNumber > layerCount) {
+        console.error(`${movement} is not valid for the current cubeType. For inputs like xR it should follow that x <= ${layerCount}.`);
+        return undefined;
+    }
+
+    const movementType = result[2];
+    const rotationNumber = result[3] ? parseInt(result[3]) % 4 : 1;
+    const isPrime = result[4] === "'";
+    const direction = (isPrime ? -1 : 1) * rotationNumber;
+
+    let axis = undefined;
+    switch (movementType) {
+        case 'R':
+        case 'Rw':
+        case 'r':
+        case 'L':
+        case 'Lw':
+        case 'l':
+        case 'M':
+        case 'm':
+            axis = Axi.x;
+            break;
+        case 'U':
+        case 'Uw':
+        case 'u':
+        case 'D':
+        case 'Dw':
+        case 'd':
+        case 'E':
+        case 'e':
+            axis = Axi.y;
+            break;
+        case 'F':
+        case 'Fw':
+        case 'f':
+        case 'B':
+        case 'Bw':
+        case 'b':
+        case 'S':
+        case 's':
+            axis = Axi.z;
+            break;
+        default:
+            console.error(`${movement} is invalid. Invalid movementType ${movementType}.`);
+    }
+    if (axis == null) {
+        return undefined;
+    }
+
+    switch (movementType) {
+        case 'R':
+        case 'U':
+        case 'F': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            const layerIndex = layerCount - layerNumber;
+            let sliceLayers = [layerIndex];
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerCount - layerRangeUpper, layerCount - (layerRangeLower - 1));
+            }
+            return { axis, layerIds: sliceLayers, direction: -direction };
+        }
+        case 'L':
+        case 'D':
+        case 'B': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            const layerIndex = layerNumber - 1;
+            let sliceLayers = [layerIndex];
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerRangeLower - 1, layerRangeUpper);
+            }
+            return { axis, layerIds: sliceLayers, direction };
+        }
+        case 'Rw':
+        case 'Uw':
+        case 'Fw':
+        case 'r':
+        case 'u':
+        case 'f': {
+            layerNumber = layerNumber ? layerNumber : 2;
+            let sliceLayers = range(layerCount - layerNumber, layerCount);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerCount - layerRangeUpper, layerCount - (layerRangeLower - 1));
+            }
+            return { axis, layerIds: sliceLayers, direction: -direction };
+        }
+        case 'Lw':
+        case 'Dw':
+        case 'Bw':
+        case 'l':
+        case 'd':
+        case 'b': {
+            layerNumber = layerNumber ? layerNumber : 2;
+            let sliceLayers = range(0, layerNumber);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerRangeLower - 1, layerRangeUpper);
+            }
+            return { axis, layerIds: sliceLayers, direction };
+        }
+        case 'M':
+        case 'E': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            const lower = Math.max(Math.floor(layerCount / 2) - (layerNumber - 1), 1);
+            const upper = Math.min(Math.ceil(layerCount / 2) + (layerNumber - 1), layerCount - 1);
+            let sliceLayers = range(lower, upper);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerCount - layerRangeUpper, layerCount - (layerRangeLower - 1));
+            }
+            return { axis, layerIds: sliceLayers, direction };
+        }
+        case 'm':
+        case 'e': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            let sliceLayers = range(layerNumber, layerCount - layerNumber);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerCount - layerRangeUpper, layerCount - (layerRangeLower - 1));
+            }
+            return { axis, layerIds: sliceLayers, direction };
+        }
+        case 'S': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            const lower = Math.max(Math.floor(layerCount / 2) - (layerNumber - 1), 1);
+            const upper = Math.min(Math.ceil(layerCount / 2) + (layerNumber - 1), layerCount - 1);
+            let sliceLayers = range(lower, upper);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerRangeLower - 1, layerRangeUpper);
+            }
+            return { axis, layerIds: sliceLayers, direction: -direction };
+        }
+        case 's': {
+            layerNumber = layerNumber ? layerNumber : 1;
+            let sliceLayers = range(layerNumber, layerCount - layerNumber);
+            if (layerRangeLower != null && layerRangeUpper != null) {
+                sliceLayers = range(layerRangeLower - 1, layerRangeUpper);
+            }
+            return { axis, layerIds: sliceLayers, direction: -direction };
+        }
+        default:
+            console.error(`${movement} is invalid. Invalid movementType ${movementType}.`);
+            return undefined;
+    }
+}
+
+/**
+ * @param {Rotation} rotation
+ * @param {number} layerCount
+ * @returns {Slice | undefined}
+ */
+export function GetRotationSlice(rotation, layerCount) {
+    const result = RegExp(`^([xyz])(\\d)?(\')?$`).exec(rotation);
+    if (result == null) {
+        console.error(`Failed to parse rotation. invalid rotation: [${rotation}]`);
+        return undefined;
+    }
+    const rotationType = result[1];
+    const rotationNumber = result[2] ? parseInt(result[2]) : 1;
+
+    const isPrime = result[3] === "'";
+    const direction = (isPrime ? 1 : -1) * (rotationNumber % 4);
+    switch (rotationType) {
+        case Rotations.x:
+            return { axis: Axi.x, layerIds: range(layerCount), direction };
+        case Rotations.y:
+            return { axis: Axi.y, layerIds: range(layerCount), direction };
+        case Rotations.z:
+            return { axis: Axi.z, layerIds: range(layerCount), direction };
+        default:
+            console.error(`Failed to get rotation slice. invalid rotationType: ${rotationType}`);
+            return undefined;
+    }
+}
+
+/**
+ *
+ * @param {number} start
+ * @param {number} [stop]
+ * @param {number} [step=1]
+ * @returns {number[]}
+ */
+const range = (start, stop, step = 1) => {
+    if (stop === undefined) {
+        stop = start;
+        start = 0;
+    }
+
+    const length = Math.max(Math.ceil((stop - start) / step), 0);
+    return Array.from({ length }, (_, i) => start + i * step);
+};