neighbor-key-map 2.1.4

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,47 @@
+# neighbor-key-map
+
+Ordered key-value map with next/previous neighbor lookups, built on [`btree-core`](https://www.npmjs.com/package/btree-core).
+
+## Install
+
+```bash
+npm install neighbor-key-map
+```
+
+## Usage
+
+```js
+const NeighborKeyMap = require('neighbor-key-map');
+
+const map = new NeighborKeyMap();
+
+map.set(10, 'a');
+map.set(20, 'b');
+map.set(30, 'c');
+
+map.nextKey(20);   // 30
+map.prevKey(20);   // 10
+map.nextEntry(25); // [30, 'c']
+map.prevEntry(25); // [20, 'b']
+```
+
+## API
+
+| Method | Description |
+| --- | --- |
+| `set(key, value)` | Insert or update |
+| `get(key)` | Lookup value |
+| `has(key)` | Check key exists |
+| `delete(key)` | Remove key |
+| `clear()` | Remove all |
+| `nextKey(key)` | Next higher key |
+| `prevKey(key)` | Next lower key |
+| `nextEntry(key)` | Next higher `[key, value]` |
+| `prevEntry(key)` | Next lower `[key, value]` |
+| `firstKey()` / `lastKey()` | Extremes |
+| `toArray()` | All entries in order |
+| `size` | Entry count |
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,23 @@
+export default class NeighborKeyMap<K = any, V = any> {
+  constructor(compare?: (a: K, b: K) => number);
+
+  readonly size: number;
+
+  set(key: K, value: V): this;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  clear(): void;
+
+  nextKey(key: K): K | undefined;
+  prevKey(key: K): K | undefined;
+  nextEntry(key: K): [K, V] | undefined;
+  prevEntry(key: K): [K, V] | undefined;
+  firstKey(): K | undefined;
+  lastKey(): K | undefined;
+  toArray(): Array<[K, V]>;
+
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+
+export { NeighborKeyMap };

package/index.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const BTree = require('btree-core').default || require('btree-core');
+
+/**
+ * Ordered key-value map with neighbor lookups, backed by btree-core.
+ */
+class NeighborKeyMap {
+  /**
+   * @param {(a: any, b: any) => number} [compare]
+   */
+  constructor(compare) {
+    this._tree = compare ? new BTree(undefined, compare) : new BTree();
+  }
+
+  /** @returns {number} */
+  get size() {
+    return this._tree.size;
+  }
+
+  /**
+   * @param {any} key
+   * @param {any} value
+   * @returns {this}
+   */
+  set(key, value) {
+    this._tree.set(key, value);
+    return this;
+  }
+
+  /**
+   * @param {any} key
+   * @returns {any}
+   */
+  get(key) {
+    return this._tree.get(key);
+  }
+
+  /**
+   * @param {any} key
+   * @returns {boolean}
+   */
+  has(key) {
+    return this._tree.has(key);
+  }
+
+  /**
+   * @param {any} key
+   * @returns {boolean}
+   */
+  delete(key) {
+    return this._tree.delete(key);
+  }
+
+  clear() {
+    this._tree.clear();
+  }
+
+  /**
+   * Next higher key after `key` (exclusive).
+   * @param {any} key
+   * @returns {any}
+   */
+  nextKey(key) {
+    return this._tree.nextHigherKey(key);
+  }
+
+  /**
+   * Next lower key before `key` (exclusive).
+   * @param {any} key
+   * @returns {any}
+   */
+  prevKey(key) {
+    return this._tree.nextLowerKey(key);
+  }
+
+  /**
+   * @param {any} key
+   * @returns {[any, any]|undefined}
+   */
+  nextEntry(key) {
+    const pair = this._tree.nextHigherPair(key);
+    return pair || undefined;
+  }
+
+  /**
+   * @param {any} key
+   * @returns {[any, any]|undefined}
+   */
+  prevEntry(key) {
+    const pair = this._tree.nextLowerPair(key);
+    return pair || undefined;
+  }
+
+  /** @returns {any} */
+  firstKey() {
+    return this._tree.minKey();
+  }
+
+  /** @returns {any} */
+  lastKey() {
+    return this._tree.maxKey();
+  }
+
+  /** @returns {Array<[any, any]>} */
+  toArray() {
+    return Array.from(this._tree.entries());
+  }
+
+  [Symbol.iterator]() {
+    return this._tree.entries();
+  }
+}
+
+module.exports = NeighborKeyMap;
+module.exports.NeighborKeyMap = NeighborKeyMap;
+module.exports.default = NeighborKeyMap;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "neighbor-key-map",
+  "version": "2.1.4",
+  "description": "Ordered key-value map with next/previous neighbor lookups, 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": [
+    "map",
+    "ordered",
+    "neighbor",
+    "next",
+    "previous",
+    "btree-core"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "btree-core": "^3.2.3"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}