data-structure-typed 2.5.3 → 2.6.0

package/.husky/pre-commit

@@ -0,0 +1,3 @@
+#!/bin/sh
+echo "🔍 Pre-commit: check + lint + integration tests..."
+npm run check && npm run lint && npx jest --config jest.integration.config.js

package/CHANGELOG.md

@@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file.
 - [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 - [`auto-changelog`](https://github.com/CookPete/auto-changelog)
 
-## [v2.5.3](https://github.com/zrwusa/data-structure-typed/compare/v2.5.3...main) (upcoming)
+## [v2.6.0](https://github.com/zrwusa/data-structure-typed/compare/v2.5.3...main) (upcoming)
 
 ## [v2.5.3](https://github.com/zrwusa/data-structure-typed/compare/v2.5.1...v2.5.3) (31 March 2026)
 

package/MIGRATION.md

@@ -124,10 +124,58 @@ heap.deleteBy(e => e.id === 42);
 heap.deleteWhere(e => e.id === 42);
 ```
 
+#### `DoublyLinkedList.getBackward()` → use `findLast()`
+
+```typescript
+// Deprecated
+list.getBackward(node => node.value > 5);
+
+// Preferred (aligns with ES2023 Array.findLast)
+list.findLast(node => node.value > 5);
+```
+
 ---
 
 ### New Features
 
+#### Array-Compatible APIs (v2.5.4+)
+
+All `IterableElementBase` containers (Queue, Deque, Stack, LinkedList, Heap, Trie) now support:
+
+```typescript
+structure.includes(element);    // alias for has()
+[...structure.entries()];       // [[0, val0], [1, val1], ...]
+[...structure.keys()];          // [0, 1, 2, ...]
+structure.toReversed();         // new instance, reversed (linear containers)
+```
+
+#### Back-to-Front Search (v2.5.4+)
+
+```typescript
+// Deque + DoublyLinkedList
+deque.findLast(v => v > 10);       // last matching value
+deque.findLastIndex(v => v > 10);  // last matching index, or -1
+```
+
+#### TreeSet ES2025 Set Operations (v2.5.4+)
+
+```typescript
+const a = new TreeSet([1, 2, 3, 4, 5]);
+const b = new TreeSet([3, 4, 5, 6, 7]);
+
+a.union(b);               // TreeSet [1,2,3,4,5,6,7]
+a.intersection(b);        // TreeSet [3,4,5]
+a.difference(b);          // TreeSet [1,2]
+a.symmetricDifference(b); // TreeSet [1,2,6,7]
+a.isSubsetOf(b);          // false
+a.isSupersetOf(b);        // false
+a.isDisjointFrom(b);      // false
+
+// Works with any Iterable
+a.union([10, 11]);
+a.intersection(new Set([2, 4]));
+```
+
 #### `deleteWhere()` — conditional deletion
 
 Available on: `TreeMap`, `TreeSet`, `TreeMultiMap`, `TreeMultiSet`, `DoublyLinkedList`, `Queue`, `Heap`

package/README.md

@@ -2,9 +2,9 @@
 
 English | [简体中文](./README_CN.md)
 
-A production-ready TypeScript data structures library featuring **Heap, Priority Queue, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, SkipList, Segment Tree**, and more — with an API that feels as intuitive as JavaScript's native `Array`. Zero dependencies. Type-safe. Supports rank queries (`getRank`), positional access (`getByRank`), and range queries (`rangeByRank`).
+A production-ready TypeScript data structures library featuring **Heap, Linked List, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, SkipList, Segment Tree**, and more — with APIs that align with JavaScript's native **Array, Map, and Set**. Zero dependencies. Type-safe. ES2025 Set operations. O(log n) rank & range queries.
 
-> **Looking for a TreeMap or TreeSet in JavaScript?** Need a priority queue, an ordered set, or efficient rank/range queries? Tired of repeatedly sorting arrays after every insert? This library provides all of that with a unified, Array-like API.
+> **Looking for a TreeMap, TreeSet, or PriorityQueue in TypeScript/JavaScript?** Familiar API, set operations, rank queries, sorted access — no more repeated `Array.sort()`.
 
 ![npm](https://img.shields.io/npm/dm/data-structure-typed)
 ![GitHub contributors](https://img.shields.io/github/contributors/zrwusa/data-structure-typed)
@@ -362,6 +362,24 @@ taskQueue.add({ priority: 9, task: 'Alert' });  // Instant priority handling
 const nextTask = taskQueue.pop();  // { priority: 9, task: 'Alert' }
 ```
 
+### Set Operations (ES2025)
+
+```typescript
+import { TreeSet } from 'data-structure-typed';
+
+const a = new TreeSet([1, 2, 3, 4, 5]);
+const b = new TreeSet([3, 4, 5, 6, 7]);
+
+[...a.union(b)];               // [1,2,3,4,5,6,7]
+[...a.intersection(b)];        // [3,4,5]
+[...a.difference(b)];          // [1,2]
+[...a.symmetricDifference(b)]; // [1,2,6,7]
+a.isSubsetOf(b);               // false
+
+// Works with any Iterable — native Set, arrays, generators
+a.intersection(new Set([2, 4, 6]));  // TreeSet [2, 4]
+```
+
 ### Fast Queue (FIFO)
 
 ```typescript

package/README_CN.md

@@ -2,9 +2,9 @@
 
 [English](./README.md) | 简体中文
 
-一个生产就绪的 TypeScript 数据结构库,提供 **Heap、Priority Queue、Deque、Trie、Graph、Red-Black Tree、TreeMap、TreeSet、SkipList、Segment Tree** 等数据结构,其 API 就像 JavaScript 原生 `Array` 一样直观。零依赖。类型安全。支持排名查询(`getRank`)、位置访问(`getByRank`)和范围查询(`rangeByRank`)。
+一个生产就绪的 TypeScript 数据结构库，包含 **Heap、Linked List、Deque、Trie、Graph、Red-Black Tree、TreeMap、TreeSet、SkipList、Segment Tree** 等 — API 对齐 JavaScript 原生 **Array、Map 和 Set**。零依赖。类型安全。ES2025 Set 操作。O(log n) 排名和范围查询。
 
-> **在 JavaScript 中寻找 TreeMap 或 TreeSet?** 需要优先级队列、有序集合或高效的排名/范围查询?厌倦了每次插入后反复排序数组?这个库提供了所有这些功能,并配有统一的、类似 Array 的 API。
+> **在 TypeScript/JavaScript 中寻找 TreeMap、TreeSet 或 PriorityQueue？** 熟悉的 API、集合操作、排名查询、有序访问 — 告别重复 `Array.sort()`。
 
 ![npm](https://img.shields.io/npm/dm/data-structure-typed)
 ![GitHub contributors](https://img.shields.io/github/contributors/zrwusa/data-structure-typed)
@@ -362,6 +362,24 @@ taskQueue.add({ priority: 9, task: 'Alert' });  // 即时优先级处理
 const nextTask = taskQueue.pop();  // { priority: 9, task: 'Alert' }
 ```
 
+### 集合操作 (ES2025)
+
+```typescript
+import { TreeSet } from 'data-structure-typed';
+
+const a = new TreeSet([1, 2, 3, 4, 5]);
+const b = new TreeSet([3, 4, 5, 6, 7]);
+
+[...a.union(b)];               // [1,2,3,4,5,6,7]
+[...a.intersection(b)];        // [3,4,5]
+[...a.difference(b)];          // [1,2]
+[...a.symmetricDifference(b)]; // [1,2,6,7]
+a.isSubsetOf(b);               // false
+
+// 支持任意 Iterable — 原生 Set、数组、生成器
+a.intersection(new Set([2, 4, 6]));  // TreeSet [2, 4]
+```
+
 ### 快速队列 (FIFO)
 
 ```typescript

package/SPECIFICATION.md

@@ -116,6 +116,16 @@ structure.peek(): T | undefined             // View front element (Queue/Deque/S
 structure.first: T | undefined              // View first element (getter)
 structure.last: T | undefined               // View last element (getter)
 
+// Search (back-to-front)
+structure.findLast(pred: Function): T | undefined   // Deque, DoublyLinkedList
+structure.findLastIndex(pred: Function): number     // Deque, DoublyLinkedList
+
+// Array-compatible (migration helpers)
+structure.includes(element: T): boolean     // Alias for has()
+structure.entries(): IterableIterator<[number, T]>  // [index, value] pairs
+structure.keys(): IterableIterator<number>  // Index iterator
+structure.toReversed(): this                // Non-mutating reverse (new instance)
+
 // Size and queries
 structure.size: number                      // Element count (Stack, Trie, etc.)
 structure.length: number                    // Element count (Queue, Deque, LinkedList)
@@ -167,6 +177,20 @@ heap.size: number
 heap.isEmpty(): boolean
 ```
 
+### TreeSet — ES2025 Set Operations
+
+```typescript
+treeSet.union(other: Iterable<K>): TreeSet<K>
+treeSet.intersection(other: Iterable<K>): TreeSet<K>
+treeSet.difference(other: Iterable<K>): TreeSet<K>
+treeSet.symmetricDifference(other: Iterable<K>): TreeSet<K>
+treeSet.isSubsetOf(other: Iterable<K>): boolean
+treeSet.isSupersetOf(other: Iterable<K>): boolean
+treeSet.isDisjointFrom(other: Iterable<K>): boolean
+```
+
+All accept any `Iterable<K>` (TreeSet, native Set, Array, generators).
+
 ### Array Methods (Available on All Structures)
 
 **All structures support ES6+ array methods via iteration:**

package/SPECIFICATION.zh-CN.md

@@ -116,6 +116,16 @@ structure.peek(): T | undefined             // 查看队头元素（Queue/Deque/
 structure.first: T | undefined              // 查看第一个元素（getter）
 structure.last: T | undefined               // 查看最后一个元素（getter）
 
+// 反向查找
+structure.findLast(pred: Function): T | undefined   // Deque、DoublyLinkedList
+structure.findLastIndex(pred: Function): number     // Deque、DoublyLinkedList
+
+// Array 兼容（方便迁移）
+structure.includes(element: T): boolean     // has() 的别名
+structure.entries(): IterableIterator<[number, T]>  // [index, value] 对
+structure.keys(): IterableIterator<number>  // 索引迭代器
+structure.toReversed(): this                // 非破坏性反转（返回新实例）
+
 // 大小和查询
 structure.size: number                      // 元素数量（Stack、Trie 等）
 structure.length: number                    // 元素数量（Queue、Deque、LinkedList）
@@ -167,6 +177,20 @@ heap.size: number
 heap.isEmpty(): boolean
 ```
 
+### TreeSet — ES2025 集合操作
+
+```typescript
+treeSet.union(other: Iterable<K>): TreeSet<K>              // 并集
+treeSet.intersection(other: Iterable<K>): TreeSet<K>       // 交集
+treeSet.difference(other: Iterable<K>): TreeSet<K>         // 差集
+treeSet.symmetricDifference(other: Iterable<K>): TreeSet<K>// 对称差集
+treeSet.isSubsetOf(other: Iterable<K>): boolean            // 子集判断
+treeSet.isSupersetOf(other: Iterable<K>): boolean          // 超集判断
+treeSet.isDisjointFrom(other: Iterable<K>): boolean        // 不相交判断
+```
+
+接受任何 `Iterable<K>`（TreeSet、原生 Set、数组、生成器）。
+
 ### 数组方法（所有结构上可用）
 
 **所有结构通过迭代支持 ES6+ 数组方法：**