remove alias'

Author: VastBlast

README.md

@@ -29,7 +29,7 @@ console.log(rot.move(1));     // C
 
 const set = new RotatableSet([1, 2, 3]);
 set.add(4);                   // Set-style add (unique, returns this)
-set.addItem(4);               // false (already present)
+set.add(4);                   // no-op for duplicates
 console.log(set.next());      // 1
 console.log(set.getFurthestItem()); // 4
 ```
@@ -77,17 +77,16 @@ The cursor always points at the item that `next()` will return.
 | method                | summary                                                     |
 | --------------------- | ----------------------------------------------------------- |
 | `add(item)`           | Set‑style add (unique), returns `this`                      |
-| `addItem(item)`       | boolean add helper (`true` if inserted)                     |
 | `delete(item)`        | Set‑style delete, returns `boolean`                         |
-| `removeItem(item)`    | alias for `delete`                                          |
 | `next()`              | return current, advance (wraps)                             |
 | `peek()`              | read current without advancing                              |
 | `getFurthestItem()`   | item farthest from cursor in `next()` steps                 |
 | `has(item)`           | membership check                                            |
+| `isEmpty`             | whether the set has zero items                              |
 | `clear()`             | remove all items                                            |
 | `toArray()` *(O(n))*  | snapshot in rotation order starting from cursor             |
 | `toSet()` *(O(n))*    | finite snapshot as native `Set` (in insertion order)        |
-| `size` / `length`     | item count                                                  |
+| `size`                | item count                                                  |
 | `Symbol.iterator`     | infinite iterator (never `done`)                            |
 | `cycle()` *(O(n))*    | one full pass starting at cursor                            |
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rotatable-array",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Allows you to rotate/iterate through an array in a circular manner.",
   "scripts": {
     "build": "tsdown",

src/rotatableSet.ts

@@ -24,7 +24,7 @@ export class RotatableSet<T> implements Iterable<T> {
 
     constructor(items: readonly T[] = []) {
         for (const item of items) {
-            this.addItem(item);
+            this.add(item);
         }
     }
 
@@ -33,11 +33,6 @@ export class RotatableSet<T> implements Iterable<T> {
         return this._size;
     }
 
-    /** Alias for `size` for parity with arrays. */
-    get length(): number {
-        return this._size;
-    }
-
     /** Whether the set is empty. */
     get isEmpty(): boolean {
         return this._size === 0;
@@ -86,16 +81,6 @@ export class RotatableSet<T> implements Iterable<T> {
         return this;
     }
 
-    /**
-     * Alias for `add` that reports whether insertion happened.
-     * @returns `true` if the item was added, `false` if it already existed.
-     */
-    addItem(item: T): boolean {
-        if (this.nodes.has(item)) return false;
-        this.add(item);
-        return true;
-    }
-
     /**
      * Remove `item` from the set. Matches native `Set.delete`.
      * @returns `true` if the item was removed.
@@ -122,11 +107,6 @@ export class RotatableSet<T> implements Iterable<T> {
         return true;
     }
 
-    /** Alias for `delete` for parity with earlier API. */
-    removeItem(item: T): boolean {
-        return this.delete(item);
-    }
-
     /**
      * Get the furthest item from the current cursor in terms of `next()` steps.
      * For non-empty sets this is always the previous item.

test/rotatableSet.test.ts

@@ -5,21 +5,19 @@ describe("RotatableSet", () => {
     it("starts empty and throws on next/furthest/peek", () => {
         const ring = new RotatableSet<number>();
         expect(ring.size).toBe(0);
-        expect(ring.length).toBe(0);
         expect(ring.isEmpty).toBe(true);
         expect(() => ring.next()).toThrowError(/empty/i);
         expect(() => ring.getFurthestItem()).toThrowError(/empty/i);
         expect(() => ring.peek()).toThrowError(/empty/i);
-        expect(ring.removeItem(1)).toBe(false);
+        expect(ring.delete(1)).toBe(false);
         expect([...ring.cycle()]).toEqual([]);
         expect(Array.from(ring.toSet())).toEqual([]);
     });
 
     it("preserves insertion order when adding to empty ring", () => {
         const ring = new RotatableSet<number>();
-        expect(ring.addItem(1)).toBe(true);
-        expect(ring.addItem(2)).toBe(true);
-        expect(ring.addItem(3)).toBe(true);
+        ring.add(1).add(2).add(3);
+        expect(ring.size).toBe(3);
         expect(ring.toArray()).toEqual([1, 2, 3]);
         expect(ring.next()).toBe(1);
         expect(ring.next()).toBe(2);
@@ -42,25 +40,25 @@ describe("RotatableSet", () => {
         expect(ring.toArray()).toEqual([1, 2, 3]);
     });
 
-    it("addItem does not move the cursor", () => {
+    it("add does not move the cursor", () => {
         const ring = new RotatableSet([1, 2, 3]);
         ring.next(); // 1, cursor at 2
-        ring.addItem(4);
+        ring.add(4);
         expect(ring.peek()).toBe(2);
         expect(ring.toArray()).toEqual([2, 3, 1, 4]);
         expect(ring.next()).toBe(2);
     });
 
-    it("addItem returns false for existing items and keeps state unchanged", () => {
+    it("adding an existing item keeps state unchanged", () => {
         const ring = new RotatableSet([1, 2, 3]);
         ring.next(); // 1, cursor at 2
-        expect(ring.addItem(2)).toBe(false);
+        ring.add(2); // duplicate
         expect(ring.size).toBe(3);
         expect(ring.peek()).toBe(2);
         expect(ring.toArray()).toEqual([2, 3, 1]);
     });
 
-    it("add() matches Set semantics and is an alias for addItem", () => {
+    it("add() matches Set semantics", () => {
         const ring = new RotatableSet<number>();
         const ret = ring.add(1).add(2);
         expect(ret).toBe(ring);
@@ -121,19 +119,19 @@ describe("RotatableSet", () => {
         expect([...ring.cycle()]).toEqual(["only"]);
     });
 
-    it("removeItem removes items and maintains cursor", () => {
+    it("delete removes items and maintains cursor", () => {
         const ring = new RotatableSet([1, 2, 3]);
         ring.next(); // 1, cursor at 2
-        expect(ring.removeItem(2)).toBe(true); // remove current
+        expect(ring.delete(2)).toBe(true); // remove current
         expect(ring.peek()).toBe(3);
         expect(ring.size).toBe(2);
         expect([...ring.cycle()]).toEqual([3, 1]);
 
-        expect(ring.removeItem(99)).toBe(false);
+        expect(ring.delete(99)).toBe(false);
         expect(ring.size).toBe(2);
     });
 
-    it("delete() matches Set semantics and is an alias for removeItem", () => {
+    it("delete() matches Set semantics", () => {
         const ring = new RotatableSet([1, 2, 3]);
         expect(ring.delete(2)).toBe(true);
         expect(ring.delete(2)).toBe(false);
@@ -144,24 +142,24 @@ describe("RotatableSet", () => {
     it("removing current from a 2-item set leaves the other item current", () => {
         const ring = new RotatableSet(["A", "B"]);
         ring.next(); // A, cursor at B
-        expect(ring.removeItem("B")).toBe(true);
+        expect(ring.delete("B")).toBe(true);
         expect(ring.size).toBe(1);
         expect(ring.peek()).toBe("A");
         expect(ring.getFurthestItem()).toBe("A");
     });
 
-    it("removeItem of a non-current item does not move the cursor", () => {
+    it("deleting a non-current item does not move the cursor", () => {
         const ring = new RotatableSet([1, 2, 3, 4]);
         ring.next(); // 1, cursor at 2
-        expect(ring.removeItem(4)).toBe(true);
+        expect(ring.delete(4)).toBe(true);
         expect(ring.peek()).toBe(2);
         expect(ring.toArray()).toEqual([2, 3, 1]);
         expect(ring.getFurthestItem()).toBe(1);
     });
 
-    it("enforces uniqueness on addItem", () => {
+    it("enforces uniqueness on add", () => {
         const ring = new RotatableSet([1, 2, 3]);
-        expect(ring.addItem(2)).toBe(false);
+        ring.add(2);
         expect(ring.size).toBe(3);
         expect(ring.toArray()).toEqual([1, 2, 3]);
     });
@@ -178,11 +176,11 @@ describe("RotatableSet", () => {
 
     it("removing the last item resets ring and allows fresh adds", () => {
         const ring = new RotatableSet<number>([10]);
-        expect(ring.removeItem(10)).toBe(true);
+        expect(ring.delete(10)).toBe(true);
         expect(ring.size).toBe(0);
         expect(() => ring.next()).toThrowError(/empty/i);
-        ring.addItem(20);
-        ring.addItem(30);
+        ring.add(20);
+        ring.add(30);
         expect(ring.toArray()).toEqual([20, 30]);
         expect(ring.next()).toBe(20);
     });