rename for consistency

Author: VastBlast

README.md

@@ -1,9 +1,9 @@
 # rotatable-array
 
-Two tiny, zero‑dependency circular rotators for TypeScript / JavaScript:
+Three tiny, zero‑dependency circular rotators for TypeScript / JavaScript:
 
 - `RotatableArray<T>`: an **immutable**, **non‑empty** round‑robin view over a backing array.
-- `MutatableRotatableArray<T>`: a **mutable**, **non-empty** round-robin array with add/remove.
+- `RotatableMutatableArray<T>`: a **mutable**, **non-empty** round-robin array with add/remove.
 - `RotatableSet<T>`: a **mutable**, **unique‑item** round‑robin set with O(1) add/remove/next.
 
 ---
@@ -19,7 +19,7 @@ npm i rotatable-array
 ## Quick Start
 
 ```ts
-import { MutatableRotatableArray, RotatableArray, RotatableSet } from "rotatable-array";
+import { RotatableMutatableArray, RotatableArray, RotatableSet } from "rotatable-array";
 
 const rot = new RotatableArray(["A", "B", "C"]);
 console.log(rot.next());      // A
@@ -28,7 +28,7 @@ console.log(rot.next());      // B
 console.log(rot.previous());  // B
 console.log(rot.move(1));     // C
 
-const mut = new MutatableRotatableArray(["A", "B"]);
+const mut = new RotatableMutatableArray(["A", "B"]);
 mut.add("C");
 mut.removeAt(1);
 console.log(mut.next());      // A
@@ -102,7 +102,7 @@ The cursor always points at the item that `next()` will return.
 
 Note: because the iterator is infinite, use `toArray()`, `toSet()`, or `cycle()` for finite snapshots.
 
-### MutatableRotatableArray
+### RotatableMutatableArray
 
 Mutable, ordered, circular array. Inherits all `RotatableArray` methods and adds:
 

src/rotatableArray.ts

@@ -128,7 +128,7 @@ export class RotatableArray<T> extends RotatableArrayBase<T> {
     }
 }
 
-export class MutatableRotatableArray<T> extends RotatableArrayBase<T> {
+export class RotatableMutatableArray<T> extends RotatableArrayBase<T> {
     /**
      * @param src   A **non-empty** array used as backing store.
      * @param copy  If `true` (default) we clone `src`; otherwise we reference it
@@ -177,7 +177,7 @@ export class MutatableRotatableArray<T> extends RotatableArrayBase<T> {
     removeAt(index: number): T {
         this.assertRemoveIndex(index);
         if (this.length === 1) {
-            throw new Error("MutatableRotatableArray must contain at least one element");
+            throw new Error("RotatableMutatableArray must contain at least one element");
         }
         if (index < this.index) {
             this.index -= 1;

test/mutatableRotatableArray.test.ts test/rotatableMutatableArray.test.tstest/mutatableRotatableArray.test.ts renamed to test/rotatableMutatableArray.test.ts

@@ -1,13 +1,13 @@
 import { describe, it, expect } from "vitest";
-import { MutatableRotatableArray } from "../src/index";
+import { RotatableMutatableArray } from "../src/index";
 
-describe("MutatableRotatableArray", () => {
+describe("RotatableMutatableArray", () => {
     it("throws on empty source array", () => {
-        expect(() => new MutatableRotatableArray([])).toThrowError(/non-empty/i);
+        expect(() => new RotatableMutatableArray([])).toThrowError(/non-empty/i);
     });
 
     it("push/add appends without moving the cursor", () => {
-        const rot = new MutatableRotatableArray(["A", "B"]);
+        const rot = new RotatableMutatableArray(["A", "B"]);
         rot.setIndex(1); // B
         expect(rot.push("C")).toBe(3);
         expect(rot.add("D")).toBe(4);
@@ -16,7 +16,7 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("next() reflects new items appended mid-rotation", () => {
-        const rot = new MutatableRotatableArray([1, 2, 3]);
+        const rot = new RotatableMutatableArray([1, 2, 3]);
         expect(rot.next()).toBe(1);
         rot.push(4);
         rot.push(5);
@@ -28,21 +28,21 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("insert() before or at the cursor keeps the same current item", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C"]);
         rot.setIndex(1); // B
         rot.insert(0, "X");
         expect(rot.peek()).toBe("B");
         expect([...rot.cycle()]).toEqual(["B", "C", "X", "A"]);
 
-        const rot2 = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot2 = new RotatableMutatableArray(["A", "B", "C"]);
         rot2.setIndex(1); // B
         rot2.insert(1, "Y");
         expect(rot2.peek()).toBe("B");
         expect([...rot2.cycle()]).toEqual(["B", "C", "A", "Y"]);
     });
 
     it("insert() after the cursor does not move the cursor", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C"]);
         rot.setIndex(1); // B
         rot.insert(3, "D"); // append
         expect(rot.peek()).toBe("B");
@@ -54,7 +54,7 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("insert() at index 0 keeps the current item when cursor is 0", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C"]);
         rot.setIndex(0); // A
         rot.insert(0, "X");
         expect(rot.peek()).toBe("A");
@@ -66,7 +66,7 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("insert() returns the new length and allows index == length", () => {
-        const rot = new MutatableRotatableArray(["A"]);
+        const rot = new RotatableMutatableArray(["A"]);
         expect(rot.insert(1, "B")).toBe(2);
         expect(rot.length).toBe(2);
         expect(rot.next()).toBe("A");
@@ -75,28 +75,28 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("removeAt() shifts the cursor to keep the same current item", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C", "D"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C", "D"]);
         rot.setIndex(2); // C
         expect(rot.removeAt(0)).toBe("A");
         expect(rot.peek()).toBe("C");
         expect([...rot.cycle()]).toEqual(["C", "D", "B"]);
     });
 
     it("removeAt() advances when removing the current item and wraps on last", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C"]);
         rot.setIndex(1); // B
         expect(rot.removeAt(1)).toBe("B");
         expect(rot.peek()).toBe("C");
         expect([...rot.cycle()]).toEqual(["C", "A"]);
 
-        const rot2 = new MutatableRotatableArray(["A", "B", "C"]);
+        const rot2 = new RotatableMutatableArray(["A", "B", "C"]);
         rot2.setIndex(2); // C
         rot2.removeAt(2);
         expect(rot2.peek()).toBe("A");
     });
 
     it("removeAt() after the cursor keeps the cursor position", () => {
-        const rot = new MutatableRotatableArray(["A", "B", "C", "D"]);
+        const rot = new RotatableMutatableArray(["A", "B", "C", "D"]);
         rot.setIndex(1); // B
         expect(rot.removeAt(3)).toBe("D");
         expect(rot.peek()).toBe("B");
@@ -107,7 +107,7 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("removeAt() on a 2-item array leaves the remaining item current", () => {
-        const rot = new MutatableRotatableArray(["A", "B"]);
+        const rot = new RotatableMutatableArray(["A", "B"]);
         rot.setIndex(0); // A
         expect(rot.removeAt(0)).toBe("A");
         expect(rot.length).toBe(1);
@@ -117,12 +117,12 @@ describe("MutatableRotatableArray", () => {
     });
 
     it("removeAt() throws when removing the last element", () => {
-        const rot = new MutatableRotatableArray(["only"]);
+        const rot = new RotatableMutatableArray(["only"]);
         expect(() => rot.removeAt(0)).toThrowError(/at least one/i);
     });
 
     it("validates indices for insert/remove", () => {
-        const rot = new MutatableRotatableArray(["A", "B"]);
+        const rot = new RotatableMutatableArray(["A", "B"]);
         expect(() => rot.insert(-1, "X")).toThrow(RangeError);
         expect(() => rot.insert(3, "X")).toThrow(RangeError);
         expect(() => rot.insert(0.5, "X")).toThrow(RangeError);
@@ -136,13 +136,13 @@ describe("MutatableRotatableArray", () => {
 
     it("respects copy=true vs copy=false semantics", () => {
         const srcForCopy = [1, 2];
-        const copied = new MutatableRotatableArray(srcForCopy, true);
+        const copied = new RotatableMutatableArray(srcForCopy, true);
         copied.push(3);
         expect(srcForCopy).toEqual([1, 2]);
         expect(copied.toArray()).toEqual([1, 2, 3]);
 
         const srcForShare = [1, 2];
-        const shared = new MutatableRotatableArray(srcForShare, false);
+        const shared = new RotatableMutatableArray(srcForShare, false);
         shared.push(3);
         expect(srcForShare).toEqual([1, 2, 3]);
         srcForShare.push(4);