Expose internal extensions from processors

Author: lambdalisue

denops/fall/processor/collect.ts

@@ -20,18 +20,16 @@ export type CollectProcessorOptions = {
 export class CollectProcessor<T extends Detail> implements Disposable {
   readonly #controller: AbortController = new AbortController();
   readonly #items: IdItem<T>[] = [];
-  readonly #source: Source<T>;
   readonly #threshold: number;
   readonly #chunkSize: number;
   readonly #chunkInterval: number;
   #processing?: Promise<void>;
   #paused?: PromiseWithResolvers<void>;
 
   constructor(
-    source: Source<T>,
+    readonly source: Source<T>,
     options: CollectProcessorOptions = {},
   ) {
-    this.#source = source;
     this.#threshold = options.threshold ?? THRESHOLD;
     this.#chunkSize = options.chunkSize ?? CHUNK_SIZE;
     this.#chunkInterval = options.chunkInterval ?? CHUNK_INTERVAL;
@@ -65,7 +63,7 @@ export class CollectProcessor<T extends Detail> implements Disposable {
       dispatch({ type: "collect-processor-started" });
       const signal = this.#controller.signal;
       const iter = take(
-        this.#source.collect(denops, params, { signal }),
+        this.source.collect(denops, params, { signal }),
         this.#threshold,
       );
       const update = (chunk: Iterable<IdItem<T>>) => {

denops/fall/processor/match.ts

@@ -22,7 +22,7 @@ export type MatchProcessorOptions = {
 };
 
 export class MatchProcessor<T extends Detail> implements Disposable {
-  readonly #matchers: ItemBelt<Matcher<T>>;
+  readonly matchers: ItemBelt<Matcher<T>>;
   readonly #interval: number;
   readonly #threshold: number;
   readonly #chunkSize: number;
@@ -37,7 +37,7 @@ export class MatchProcessor<T extends Detail> implements Disposable {
     matchers: readonly [Matcher<T>, ...Matcher<T>[]],
     options: MatchProcessorOptions = {},
   ) {
-    this.#matchers = new ItemBelt(matchers);
+    this.matchers = new ItemBelt(matchers);
     this.#interval = options.interval ?? INTERVAL;
     this.#threshold = options.threshold ?? THRESHOLD;
     this.#chunkSize = options.chunkSize ?? CHUNK_SIZE;
@@ -46,26 +46,26 @@ export class MatchProcessor<T extends Detail> implements Disposable {
   }
 
   get #matcher(): Matcher<T> {
-    return this.#matchers.current!;
+    return this.matchers.current!;
   }
 
   get items(): IdItem<T>[] {
     return this.#items;
   }
 
   get matcherCount(): number {
-    return this.#matchers.count;
+    return this.matchers.count;
   }
 
   get matcherIndex(): number {
-    return this.#matchers.index;
+    return this.matchers.index;
   }
 
   set matcherIndex(index: number | "$") {
     if (index === "$") {
-      index = this.#matchers.count;
+      index = this.matchers.count;
     }
-    this.#matchers.index = index;
+    this.matchers.index = index;
   }
 
   #validateAvailability(): void {

denops/fall/processor/preview.ts

@@ -10,32 +10,32 @@ import { dispatch } from "../event.ts";
 
 export class PreviewProcessor<T extends Detail> implements Disposable {
   readonly #controller: AbortController = new AbortController();
-  readonly #previewers: ItemBelt<Previewer<T>>;
+  readonly previewers: ItemBelt<Previewer<T>>;
   #processing?: Promise<void>;
   #reserved?: () => void;
   #item: PreviewItem | undefined = undefined;
 
   constructor(previewers: readonly Previewer<T>[]) {
-    this.#previewers = new ItemBelt(previewers);
+    this.previewers = new ItemBelt(previewers);
   }
 
   get #previewer(): Previewer<T> | undefined {
-    return this.#previewers.current;
+    return this.previewers.current;
   }
 
   get previewerCount(): number {
-    return this.#previewers.count;
+    return this.previewers.count;
   }
 
   get previewerIndex(): number {
-    return this.#previewers.index;
+    return this.previewers.index;
   }
 
   set previewerIndex(index: number | "$") {
     if (index === "$") {
-      index = this.#previewers.count;
+      index = this.previewers.count;
     }
-    this.#previewers.index = index;
+    this.previewers.index = index;
   }
 
   get item(): PreviewItem | undefined {

denops/fall/processor/render.ts

@@ -20,7 +20,7 @@ export type RenderProcessorOptions = {
 
 export class RenderProcessor<T extends Detail> implements Disposable {
   readonly #controller: AbortController = new AbortController();
-  readonly #renderers: ItemBelt<Renderer<T>>;
+  readonly renderers: ItemBelt<Renderer<T>>;
   #height: number;
   #scrollOffset: number;
   #processing?: Promise<void>;
@@ -34,28 +34,28 @@ export class RenderProcessor<T extends Detail> implements Disposable {
     renderers: readonly Renderer<T>[],
     options: RenderProcessorOptions = {},
   ) {
-    this.#renderers = new ItemBelt(renderers);
+    this.renderers = new ItemBelt(renderers);
     this.#height = options.height ?? HEIGHT;
     this.#scrollOffset = options.scrollOffset ?? SCROLL_OFFSET;
   }
 
   get #renderer(): Renderer<T> | undefined {
-    return this.#renderers.current;
+    return this.renderers.current;
   }
 
   get rendererCount(): number {
-    return this.#renderers.count;
+    return this.renderers.count;
   }
 
   get rendererIndex(): number {
-    return this.#renderers.index;
+    return this.renderers.index;
   }
 
   set rendererIndex(index: number | "$") {
     if (index === "$") {
-      index = this.#renderers.count;
+      index = this.renderers.count;
     }
-    this.#renderers.index = index;
+    this.renderers.index = index;
   }
 
   get items() {

denops/fall/processor/sort.ts

@@ -7,32 +7,32 @@ import { dispatch } from "../event.ts";
 
 export class SortProcessor<T extends Detail> implements Disposable {
   readonly #controller: AbortController = new AbortController();
-  readonly #sorters: ItemBelt<Sorter<T>>;
+  readonly sorters: ItemBelt<Sorter<T>>;
   #processing?: Promise<void>;
   #reserved?: () => void;
   #items: IdItem<T>[] = [];
 
   constructor(sorters: readonly Sorter<T>[]) {
-    this.#sorters = new ItemBelt(sorters);
+    this.sorters = new ItemBelt(sorters);
   }
 
   get #sorter(): Sorter<T> | undefined {
-    return this.#sorters.current;
+    return this.sorters.current;
   }
 
   get sorterCount(): number {
-    return this.#sorters.count;
+    return this.sorters.count;
   }
 
   get sorterIndex(): number {
-    return this.#sorters.index;
+    return this.sorters.index;
   }
 
   set sorterIndex(index: number | "$") {
     if (index === "$") {
-      index = this.#sorters.count;
+      index = this.sorters.count;
     }
-    this.#sorters.index = index;
+    this.sorters.index = index;
   }
 
   get items() {