Use UniqueOrderedList and add initialItems to CollectProcessor

Author: lambdalisue

denops/fall/lib/unique_ordered_list_test.ts

@@ -67,19 +67,19 @@ Deno.test("UniqueOrderedList: initializes with items", () => {
     { id: 1, name: "Alice" },
     { id: 2, name: "Bob" },
   ]);
-  
+
   // Pushing duplicate IDs is properly prevented
   list.push({ id: 1, name: "Alice (another dup)" });
   assertEquals(list.size, 2); // Still 2, duplicate was ignored
 });
 
 Deno.test("UniqueOrderedList: works without identifier function", () => {
   const list = new UniqueOrderedList<number>([1, 2, 3, 2, 1]); // Has duplicates
-  
+
   // Initial duplicates are filtered
   assertEquals(list.size, 3);
   assertEquals(list.items, [1, 2, 3]);
-  
+
   list.push(4, 2, 5); // 2 is duplicate and will be ignored
   assertEquals(list.size, 5);
   assertEquals(list.items, [1, 2, 3, 4, 5]);

denops/fall/processor/collect.ts

@@ -5,21 +5,23 @@ import type { Detail, IdItem } from "jsr:@vim-fall/core@^0.3.0/item";
 import type { CollectParams, Source } from "jsr:@vim-fall/core@^0.3.0/source";
 
 import { Chunker } from "../lib/chunker.ts";
+import { UniqueOrderedList } from "../lib/unique_ordered_list.ts";
 import { dispatch } from "../event.ts";
 
 const THRESHOLD = 100000;
 const CHUNK_SIZE = 1000;
 const CHUNK_INTERVAL = 100;
 
-export type CollectProcessorOptions = {
+export type CollectProcessorOptions<T extends Detail> = {
+  initialItems?: readonly IdItem<T>[];
   threshold?: number;
   chunkSize?: number;
   chunkInterval?: number;
 };
 
 export class CollectProcessor<T extends Detail> implements Disposable {
   readonly #controller: AbortController = new AbortController();
-  readonly #items: IdItem<T>[] = [];
+  readonly #items: UniqueOrderedList<IdItem<T>>;
   readonly #threshold: number;
   readonly #chunkSize: number;
   readonly #chunkInterval: number;
@@ -28,15 +30,23 @@ export class CollectProcessor<T extends Detail> implements Disposable {
 
   constructor(
     readonly source: Source<T>,
-    options: CollectProcessorOptions = {},
+    options: CollectProcessorOptions<T> = {},
   ) {
     this.#threshold = options.threshold ?? THRESHOLD;
     this.#chunkSize = options.chunkSize ?? CHUNK_SIZE;
     this.#chunkInterval = options.chunkInterval ?? CHUNK_INTERVAL;
+    this.#items = new UniqueOrderedList<IdItem<T>>(
+      options.initialItems ?? [],
+      {
+        // We need to compare "value" rather than "id" for uniqueness,
+        // to implement the "resume" functionality correctly.
+        identifier: (item) => item.value,
+      },
+    );
   }
 
-  get items() {
-    return this.#items;
+  get items(): readonly IdItem<T>[] {
+    return this.#items.items;
   }
 
   #validateAvailability(): void {
@@ -67,7 +77,7 @@ export class CollectProcessor<T extends Detail> implements Disposable {
         this.#threshold,
       );
       const update = (chunk: Iterable<IdItem<T>>) => {
-        const offset = this.#items.length;
+        const offset = this.#items.size;
         this.#items.push(
           ...map(chunk, (item, i) => ({ ...item, id: i + offset })),
         );