js-fundamentals 1.0.1 → 1.0.2

package/README.md

@@ -1 +1,101 @@
 # fundamentals
+
+Small JavaScript data-structure utilities (ESM).
+
+Currently included:
+
+- `Queue`: FIFO queue
+- `PriorityQueue`: queue ordered by numeric priority (ascending by default)
+
+## Installation
+
+```bash
+npm i js-fundamentals
+```
+
+## Usage
+
+This package is **ESM-only** (`"type": "module"`).
+
+```js
+import { Queue, PriorityQueue } from "js-fundamentals";
+```
+
+### Queue
+
+```js
+import { Queue } from "js-fundamentals";
+
+const q = new Queue();
+q.enqueue("a");
+q.enqueue("b");
+
+q.peek(); // "a"
+q.dequeue(); // "a"
+q.size(); // 1
+q.toArray(); // ["b"]
+```
+
+### PriorityQueue
+
+`PriorityQueue` stores `(item, priority)` pairs internally and always dequeues the next item based on priority.
+
+By default it is **ascending** (lower numbers come out first). Pass `{ descending: true }` to the constructor for **descending** order.
+
+```js
+import { PriorityQueue } from "js-fundamentals";
+
+const pq = new PriorityQueue(); // ascending
+pq.enqueue("low", 10);
+pq.enqueue("high", 1);
+
+pq.dequeue(); // "high"
+pq.toArray(); // ["low"]
+```
+
+Descending order:
+
+```js
+const pq = new PriorityQueue({ descending: true }); // descending
+pq.enqueue("low", 1);
+pq.enqueue("high", 10);
+
+pq.dequeue(); // "high"
+```
+
+## API
+
+### `new Queue()`
+
+- `enqueue(item): void`
+- `dequeue(): any | undefined` (returns `undefined` if empty)
+- `peek(): any | undefined` (returns `undefined` if empty)
+- `isEmpty(): boolean`
+- `size(): number`
+- `toArray(): any[]` (returns the internal backing array)
+
+### `new PriorityQueue(options?)`
+
+Extends `Queue`.
+
+- `options.descending?: boolean` (default: `false`)
+- `enqueue(item, priority): void` (`priority` should be a number)
+- `dequeue(): any | undefined` (returns `undefined` if empty)
+- `peek(): any | undefined` (returns `undefined` if empty)
+- `isEmpty(): boolean`
+- `size(): number`
+- `toArray(): any[]` (returns only items, not priorities)
+- `changePriority(item, newPriority): void`
+  - Finds an existing item and updates its priority, then re-sorts the queue.
+  - Matching rules:
+    - Uses strict equality (`===`) for non-objects
+    - For non-null objects, falls back to `JSON.stringify` comparison
+  - Throws `Error("Item not found")` if no match is found.
+
+## Development
+
+```bash
+npm test
+npm run lint
+npm run format
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-fundamentals",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "homepage": "https://github.com/eetujukka1/fundamentals#readme",
   "bugs": {

package/src/priorityqueue/index.js

@@ -1,8 +1,9 @@
 import Queue from "../queue";
 
 class PriorityQueue extends Queue {
-  constructor(descending = false) {
+  constructor(options = {}) {
     super();
+    const { descending = false } = options;
     this.descending = descending;
   }
 
@@ -32,6 +33,31 @@ class PriorityQueue extends Queue {
   toArray() {
     return this.items.map((item) => item.item);
   }
+
+  changePriority(item, newPriority) {
+    const index = this.items.findIndex((i) => {
+      if (i.item === item) {
+        return true;
+      }
+
+      if (
+        typeof i.item === "object" &&
+        typeof item === "object" &&
+        i.item !== null &&
+        item !== null
+      ) {
+        return JSON.stringify(i.item) === JSON.stringify(item);
+      }
+      return false;
+    });
+    if (index === -1) {
+      throw new Error("Item not found");
+    }
+    this.items[index].priority = newPriority;
+    this.items.sort((a, b) =>
+      this.descending ? b.priority - a.priority : a.priority - b.priority,
+    );
+  }
 }
 
 export default PriorityQueue;

package/tests/priorityqueue.test.js

@@ -23,6 +23,15 @@ describe("PriorityQueue", () => {
     expect(queue.isEmpty()).toBe(false);
   });
 
+  it("should dequeue an item with descending priority", () => {
+    const queue = new PriorityQueue({ descending: true });
+    queue.enqueue(1, 1);
+    queue.enqueue(2, 2);
+    queue.enqueue(3, 3);
+    expect(queue.dequeue()).toBe(3);
+    expect(queue.isEmpty()).toBe(false);
+  });
+
   it("should peek at the front item", () => {
     const queue = new PriorityQueue();
     queue.enqueue(3, 3);
@@ -55,4 +64,13 @@ describe("PriorityQueue", () => {
     queue.enqueue(1, 1);
     expect(queue.toArray()).toEqual([1, 2, 3]);
   });
+
+  it("should change the priority of an item", () => {
+    const queue = new PriorityQueue();
+    queue.enqueue({ id: 1 }, 1);
+    queue.enqueue({ id: 2 }, 2);
+    queue.enqueue({ id: 3 }, 3);
+    queue.changePriority({ id: 2 }, 4);
+    expect(queue.toArray()).toEqual([{ id: 1 }, { id: 3 }, { id: 2 }]);
+  });
 });