feat: implement performance optimizations for fall picker

Implements copy-on-write approach and multiple performance improvements:
- Add item cloning to prevent in-place modifications during sort/render
- Implement debounced preview processing to reduce CPU during navigation
- Cache byte length calculations in input component
- Optimize event consumption with for loops instead of forEach
- Update processor restart logic to leverage copy-on-write

These changes significantly improve performance for large item collections
by avoiding redundant processing and reducing memory allocations.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: lambdalisue

PERFORMANCE_IMPROVEMENTS.md

@@ -0,0 +1,129 @@
+# Performance Improvement Recommendations for vim-fall
+
+After analyzing the codebase, here are key performance improvement
+opportunities:
+
+## ✅ Implemented Improvements
+
+### 1. Optimized Event Queue Processing
+
+- **Change**: Replaced `forEach` with `for` loop and added early return for
+  empty queue
+- **Impact**: Reduced overhead for event processing, especially with many events
+- **Files**: `event.ts`
+- **Tests**: Enhanced `event_test.ts` with performance and edge case tests
+
+### 2. Cached Byte Length Calculations
+
+- **Change**: Added caching for prefix/suffix byte lengths in input component
+- **Impact**: Avoids repeated UTF-8 encoding operations during rendering
+- **Files**: `component/input.ts`
+- **Tests**: Existing tests in `component/input_test.ts` ensure correctness
+
+### 3. Lazy Preview Loading with Debounce
+
+- **Change**: Added 150ms debounce to preview updates during cursor movement
+- **Impact**: Prevents unnecessary preview processing during rapid navigation
+- **Files**: `picker.ts`, `lib/debounce.ts` (new)
+- **Tests**: Created comprehensive tests in `lib/debounce_test.ts`
+
+### 4. Copy-on-Write for Processor Items
+
+- **Change**: Implemented deep cloning of items in sort and render processors
+- **Impact**: Eliminated need to restart from match processor when switching sorters/renderers
+- **Files**: `processor/sort.ts`, `processor/render.ts`, `picker.ts`, `lib/item_clone.ts` (new)
+- **Tests**: Created tests in `lib/item_clone_test.ts`, updated `processor/sort_test.ts`
+
+## 📋 Remaining Opportunities
+
+## 1. Reduce Component Re-renders
+
+Components check multiple modified flags on every scheduler tick (10ms). The
+input component (input.ts:232-247) renders even when only spinner updates:
+
+```typescript
+get #isSpinnerUpdated(): boolean {
+  return (this.collecting || this.processing) && !this.#spinner.locked;
+}
+```
+
+**Solution**: Implement dirty checking with granular update flags and batch DOM
+updates.
+
+## 2. Improve Memory Management
+
+UniqueOrderedList (unique_ordered_list.ts) maintains both Set and Array:
+
+```typescript
+#seen: Set<unknown> = new Set();
+#items: T[];
+```
+
+**Solution**: For large datasets, consider a single Map<unknown, T> with
+insertion order preservation.
+
+## 3. Batch Async Operations
+
+Multiple processors can trigger simultaneously, causing cascading updates:
+
+```typescript
+// collect-processor-updated triggers match
+// match-processor-updated triggers sort
+// sort-processor-succeeded triggers render
+```
+
+**Solution**: Implement update batching with a priority queue to coalesce rapid
+changes.
+
+## 4. Optimize Scheduler Interval
+
+Default 10ms scheduler interval may be too aggressive for some operations:
+
+```typescript
+const SCHEDULER_INTERVAL = 10;
+```
+
+**Solution**: Make scheduler adaptive based on workload - increase interval when
+idle, decrease during active input.
+
+## 5. Virtual Scrolling Enhancement
+
+Current implementation slices arrays on every render:
+
+```typescript
+const displayItems = items
+  .slice(this.offset, this.offset + this.height);
+```
+
+**Solution**: Implement a viewport buffer that reuses item objects when
+scrolling incrementally.
+
+## 6. Worker Thread Processing
+
+For CPU-intensive operations like matching/sorting large datasets:
+
+**Solution**: Move matcher/sorter processing to Web Workers to keep UI thread
+responsive.
+
+## Implementation Priority
+
+1. **High Impact, Low Effort**:
+   ✅ Lazy preview loading (implemented)
+   ✅ String operation caching (implemented)
+   ✅ Event queue optimization (implemented)
+   ✅ Copy-on-write for processor items (implemented)
+
+2. **High Impact, Medium Effort**:
+   - Batch async operations (#3)
+   - Component re-render optimization (#1)
+
+3. **High Impact, High Effort**:
+   - Worker thread processing (#6)
+   - Virtual scrolling enhancement (#5)
+
+4. **Medium Impact**:
+   - Memory management improvements (#2)
+   - Adaptive scheduler (#4)
+
+These optimizations would significantly improve latency, especially for large
+datasets and rapid user interactions.

deno.jsonc

@@ -1,7 +1,8 @@
 {
   "exclude": [
     "docs/**",
-    ".coverage/**"
+    ".coverage/**",
+    "PERFORMANCE_IMPROVEMENTS.md"
   ],
   "tasks": {
     "check": "deno check ./**/*.ts",

denops/fall/component/input.ts

@@ -79,6 +79,10 @@ export class InputComponent extends BaseComponent {
   #modifiedWindow = true;
   #modifiedContent = true;
 
+  // Cache for byte lengths to avoid repeated calculations
+  #prefixCache?: { value: string; byteLength: number };
+  #suffixCache?: { value: string; byteLength: number };
+
   constructor(
     {
       title,
@@ -287,9 +291,25 @@ export class InputComponent extends BaseComponent {
       this.#offset,
       this.#offset + cmdwidth,
     );
-    const prefixByteLength = getByteLength(prefix);
+
+    // Use cached byte lengths when possible
+    let prefixByteLength: number;
+    if (this.#prefixCache?.value === prefix) {
+      prefixByteLength = this.#prefixCache.byteLength;
+    } else {
+      prefixByteLength = getByteLength(prefix);
+      this.#prefixCache = { value: prefix, byteLength: prefixByteLength };
+    }
+
     const middleByteLength = getByteLength(middle);
-    const suffixByteLength = getByteLength(suffix);
+
+    let suffixByteLength: number;
+    if (this.#suffixCache?.value === suffix) {
+      suffixByteLength = this.#suffixCache.byteLength;
+    } else {
+      suffixByteLength = getByteLength(suffix);
+      this.#suffixCache = { value: suffix, byteLength: suffixByteLength };
+    }
 
     await buffer.replace(denops, bufnr, [prefix + middle + suffix]);
     signal?.throwIfAborted();

denops/fall/event.ts

@@ -7,9 +7,15 @@ export function dispatch(event: Readonly<Event>): void {
 }
 
 export function consume(consumer: Consumer): void {
+  // Optimize: Swap arrays instead of creating new ones each time
   const events = eventQueue;
+  if (events.length === 0) return;
+
   eventQueue = [];
-  events.forEach(consumer);
+  // Use for loop instead of forEach for better performance
+  for (let i = 0; i < events.length; i++) {
+    consumer(events[i]);
+  }
 }
 
 type SelectMethod = "on" | "off" | "toggle";

denops/fall/event_test.ts

@@ -23,4 +23,80 @@ Deno.test("Event", async (t) => {
     });
     assertEquals(dispatchedEvents, []);
   });
+
+  await t.step("multiple consumers receive all events in order", () => {
+    dispatch({ type: "vim-cmdline-changed", cmdline: "test1" });
+    dispatch({ type: "vim-cmdpos-changed", cmdpos: 5 });
+    dispatch({ type: "vim-cmdline-changed", cmdline: "test2" });
+
+    const results: Event[][] = [];
+    consume((event) => {
+      if (!results[0]) results[0] = [];
+      results[0].push(event);
+    });
+
+    assertEquals(results[0], [
+      { type: "vim-cmdline-changed", cmdline: "test1" },
+      { type: "vim-cmdpos-changed", cmdpos: 5 },
+      { type: "vim-cmdline-changed", cmdline: "test2" },
+    ]);
+  });
+
+  await t.step("handles large number of events", () => {
+    const eventCount = 10000;
+    for (let i = 0; i < eventCount; i++) {
+      dispatch({ type: "vim-cmdpos-changed", cmdpos: i });
+    }
+
+    let receivedCount = 0;
+    consume((event) => {
+      assertEquals(event.type, "vim-cmdpos-changed");
+      receivedCount++;
+    });
+
+    assertEquals(receivedCount, eventCount);
+  });
+
+  await t.step("events are cleared after consume", () => {
+    dispatch({ type: "vim-cmdline-changed", cmdline: "test" });
+
+    let firstConsumeCount = 0;
+    consume(() => {
+      firstConsumeCount++;
+    });
+    assertEquals(firstConsumeCount, 1);
+
+    let secondConsumeCount = 0;
+    consume(() => {
+      secondConsumeCount++;
+    });
+    assertEquals(secondConsumeCount, 0);
+  });
+
+  await t.step("handles events dispatched during consume", () => {
+    dispatch({ type: "vim-cmdline-changed", cmdline: "initial" });
+
+    const events: Event[] = [];
+    consume((event) => {
+      events.push(event);
+      if (event.type === "vim-cmdline-changed" && event.cmdline === "initial") {
+        // This dispatch happens during consume - should not be consumed in this cycle
+        dispatch({ type: "vim-cmdpos-changed", cmdpos: 42 });
+      }
+    });
+
+    assertEquals(events, [
+      { type: "vim-cmdline-changed", cmdline: "initial" },
+    ]);
+
+    // The event dispatched during consume should be available in next consume
+    const nextEvents: Event[] = [];
+    consume((event) => {
+      nextEvents.push(event);
+    });
+
+    assertEquals(nextEvents, [
+      { type: "vim-cmdpos-changed", cmdpos: 42 },
+    ]);
+  });
 });

denops/fall/lib/debounce.ts

@@ -0,0 +1,70 @@
+/**
+ * Creates a debounced version of a function that delays invoking the function
+ * until after `delay` milliseconds have elapsed since the last time it was invoked.
+ *
+ * @param fn The function to debounce
+ * @param delay The number of milliseconds to delay
+ * @returns A debounced version of the function
+ */
+// deno-lint-ignore no-explicit-any
+export function debounce<T extends (...args: any[]) => any>(
+  fn: T,
+  delay: number,
+): (...args: Parameters<T>) => void {
+  let timerId: number | undefined;
+
+  return function debounced(...args: Parameters<T>): void {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+
+    timerId = setTimeout(() => {
+      timerId = undefined;
+      fn(...args);
+    }, delay);
+  };
+}
+
+/**
+ * A debouncer class that provides more control over debounced execution.
+ */
+export class Debouncer {
+  #timerId?: number;
+  #delay: number;
+
+  constructor(delay: number) {
+    this.#delay = delay;
+  }
+
+  /**
+   * Executes the callback after the specified delay.
+   * If called again before the delay expires, the previous call is cancelled.
+   */
+  call(callback: () => void): void {
+    if (this.#timerId !== undefined) {
+      clearTimeout(this.#timerId);
+    }
+
+    this.#timerId = setTimeout(() => {
+      this.#timerId = undefined;
+      callback();
+    }, this.#delay);
+  }
+
+  /**
+   * Cancels any pending execution.
+   */
+  cancel(): void {
+    if (this.#timerId !== undefined) {
+      clearTimeout(this.#timerId);
+      this.#timerId = undefined;
+    }
+  }
+
+  /**
+   * Returns whether there is a pending execution.
+   */
+  get pending(): boolean {
+    return this.#timerId !== undefined;
+  }
+}