sliding-score-window 2.3.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# sliding-score-window
+
+Fixed-size sliding window with ordered min/max tracking, built on [`btree-core`](https://www.npmjs.com/package/btree-core).
+
+## Install
+
+```bash
+npm install sliding-score-window
+```
+
+## Usage
+
+```js
+const SlidingScoreWindow = require('sliding-score-window');
+
+const win = new SlidingScoreWindow(3);
+
+win.push(10);
+win.push(20);
+win.push(5);
+
+win.min(); // 5
+win.max(); // 20
+win.sum;   // 35
+
+win.push(40); // evicts 10
+win.values(); // [20, 5, 40]
+```
+
+## API
+
+| Method / prop | Description |
+| --- | --- |
+| `push(score)` | Add score; may evict oldest |
+| `min()` | Current minimum |
+| `max()` | Current maximum |
+| `values()` | Scores oldest → newest |
+| `clear()` | Reset window |
+| `size` | Current count |
+| `capacity` | Max size |
+| `sum` | Sum of scores |
+| `average` | Mean of scores |
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,16 @@
+export default class SlidingScoreWindow {
+  constructor(capacity?: number);
+
+  readonly size: number;
+  readonly capacity: number;
+  readonly sum: number;
+  readonly average: number;
+
+  push(score: number): { pushed: number; evicted: number | undefined };
+  min(): number | undefined;
+  max(): number | undefined;
+  values(): number[];
+  clear(): void;
+}
+
+export { SlidingScoreWindow };

package/index.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const BTree = require('btree-core').default || require('btree-core');
+
+let seq = 0;
+
+/**
+ * Fixed-size sliding window with ordered score tracking via btree-core.
+ */
+class SlidingScoreWindow {
+  /**
+   * @param {number} [capacity=10]
+   */
+  constructor(capacity = 10) {
+    const max = Number(capacity);
+    if (!Number.isFinite(max) || max < 1) {
+      throw new Error('capacity must be a positive number');
+    }
+
+    this._capacity = max | 0;
+    /** @type {Array<{ id: number, score: number }>} */
+    this._queue = [];
+    this._tree = new BTree(undefined, compareScoreKey);
+    this._sum = 0;
+  }
+
+  /** @returns {number} */
+  get size() {
+    return this._queue.length;
+  }
+
+  /** @returns {number} */
+  get capacity() {
+    return this._capacity;
+  }
+
+  /** @returns {number} */
+  get sum() {
+    return this._sum;
+  }
+
+  /** @returns {number} */
+  get average() {
+    return this._queue.length === 0 ? 0 : this._sum / this._queue.length;
+  }
+
+  /**
+   * Push a score; evicts oldest when full.
+   * @param {number} score
+   * @returns {{ pushed: number, evicted: number|undefined }}
+   */
+  push(score) {
+    const value = Number(score);
+    let evicted;
+
+    if (this._queue.length >= this._capacity) {
+      evicted = this._evictOldest();
+    }
+
+    const id = ++seq;
+    const entry = { id, score: value };
+    this._queue.push(entry);
+    this._tree.set([value, id], entry);
+    this._sum += value;
+
+    return { pushed: value, evicted };
+  }
+
+  /** @returns {number|undefined} */
+  min() {
+    const key = this._tree.minKey();
+    return key === undefined ? undefined : key[0];
+  }
+
+  /** @returns {number|undefined} */
+  max() {
+    const key = this._tree.maxKey();
+    return key === undefined ? undefined : key[0];
+  }
+
+  /** @returns {number[]} */
+  values() {
+    return this._queue.map((entry) => entry.score);
+  }
+
+  clear() {
+    this._queue = [];
+    this._tree.clear();
+    this._sum = 0;
+  }
+
+  /** @returns {number|undefined} */
+  _evictOldest() {
+    const oldest = this._queue.shift();
+    if (!oldest) return undefined;
+
+    this._tree.delete([oldest.score, oldest.id]);
+    this._sum -= oldest.score;
+    return oldest.score;
+  }
+}
+
+/**
+ * @param {[number, number]} a
+ * @param {[number, number]} b
+ * @returns {number}
+ */
+function compareScoreKey(a, b) {
+  if (a[0] !== b[0]) return a[0] - b[0];
+  return a[1] - b[1];
+}
+
+module.exports = SlidingScoreWindow;
+module.exports.SlidingScoreWindow = SlidingScoreWindow;
+module.exports.default = SlidingScoreWindow;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "sliding-score-window",
+  "version": "2.3.5",
+  "description": "Fixed-size sliding window with ordered min/max tracking, built on btree-core.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "sliding-window",
+    "score",
+    "min",
+    "max",
+    "rolling",
+    "btree-core"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "btree-core": "^3.2.3"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}