add private modifier

= requires reordering of methods because of eslint rule `@typescript-eslint/member-ordering`
= adds underscore to private `_initialResult` property for consistency

Author: yaacovCR

src/execution/IncrementalPublisher.ts

@@ -108,20 +108,20 @@ export type FormattedIncrementalResult<
  * @internal
  */
 export class IncrementalPublisher {
-  initialResult: {
+  private _initialResult: {
     children: Set<IncrementalDataRecord>;
     isCompleted: boolean;
   };
 
-  _released: Set<IncrementalDataRecord>;
-  _pending: Set<IncrementalDataRecord>;
+  private _released: Set<IncrementalDataRecord>;
+  private _pending: Set<IncrementalDataRecord>;
 
   // these are assigned within the Promise executor called synchronously within the constructor
-  _signalled!: Promise<unknown>;
-  _resolve!: () => void;
+  private _signalled!: Promise<unknown>;
+  private _resolve!: () => void;
 
   constructor() {
-    this.initialResult = {
+    this._initialResult = {
       children: new Set(),
       isCompleted: false,
     };
@@ -130,47 +130,10 @@ export class IncrementalPublisher {
     this._reset();
   }
 
-  _trigger() {
-    this._resolve();
-    this._reset();
-  }
-
-  _reset() {
-    // promiseWithResolvers uses void only as a generic type parameter
-    // see: https://typescript-eslint.io/rules/no-invalid-void-type/
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    const { promise: signalled, resolve } = promiseWithResolvers<void>();
-    this._resolve = resolve;
-    this._signalled = signalled;
-  }
-
   hasNext(): boolean {
     return this._pending.size > 0;
   }
 
-  _introduce(item: IncrementalDataRecord) {
-    this._pending.add(item);
-  }
-
-  _release(item: IncrementalDataRecord): void {
-    if (this._pending.has(item)) {
-      this._released.add(item);
-      this._trigger();
-    }
-  }
-
-  _push(item: IncrementalDataRecord): void {
-    this._released.add(item);
-    this._pending.add(item);
-    this._trigger();
-  }
-
-  _delete(item: IncrementalDataRecord) {
-    this._released.delete(item);
-    this._pending.delete(item);
-    this._trigger();
-  }
-
   subscribe(): AsyncGenerator<
     SubsequentIncrementalExecutionResult,
     void,
@@ -247,46 +210,6 @@ export class IncrementalPublisher {
     };
   }
 
-  _getIncrementalResult(
-    completedRecords: ReadonlySet<IncrementalDataRecord>,
-  ): SubsequentIncrementalExecutionResult | undefined {
-    const incrementalResults: Array<IncrementalResult> = [];
-    let encounteredCompletedAsyncIterator = false;
-    for (const incrementalDataRecord of completedRecords) {
-      const incrementalResult: IncrementalResult = {};
-      for (const child of incrementalDataRecord.children) {
-        this._publish(child);
-      }
-      if (isStreamItemsRecord(incrementalDataRecord)) {
-        const items = incrementalDataRecord.items;
-        if (incrementalDataRecord.isCompletedAsyncIterator) {
-          // async iterable resolver just finished but there may be pending payloads
-          encounteredCompletedAsyncIterator = true;
-          continue;
-        }
-        (incrementalResult as IncrementalStreamResult).items = items;
-      } else {
-        const data = incrementalDataRecord.data;
-        (incrementalResult as IncrementalDeferResult).data = data ?? null;
-      }
-
-      incrementalResult.path = incrementalDataRecord.path;
-      if (incrementalDataRecord.label != null) {
-        incrementalResult.label = incrementalDataRecord.label;
-      }
-      if (incrementalDataRecord.errors.length > 0) {
-        incrementalResult.errors = incrementalDataRecord.errors;
-      }
-      incrementalResults.push(incrementalResult);
-    }
-
-    return incrementalResults.length
-      ? { incremental: incrementalResults, hasNext: this.hasNext() }
-      : encounteredCompletedAsyncIterator && !this.hasNext()
-      ? { hasNext: false }
-      : undefined;
-  }
-
   prepareNewDeferredFragmentRecord(opts: {
     label: string | undefined;
     path: Path | undefined;
@@ -298,7 +221,7 @@ export class IncrementalPublisher {
     if (parentContext) {
       parentContext.children.add(deferredFragmentRecord);
     } else {
-      this.initialResult.children.add(deferredFragmentRecord);
+      this._initialResult.children.add(deferredFragmentRecord);
     }
 
     return deferredFragmentRecord;
@@ -316,7 +239,7 @@ export class IncrementalPublisher {
     if (parentContext) {
       parentContext.children.add(streamItemsRecord);
     } else {
-      this.initialResult.children.add(streamItemsRecord);
+      this._initialResult.children.add(streamItemsRecord);
     }
 
     return streamItemsRecord;
@@ -352,19 +275,11 @@ export class IncrementalPublisher {
   }
 
   publishInitial() {
-    for (const child of this.initialResult.children) {
+    for (const child of this._initialResult.children) {
       this._publish(child);
     }
   }
 
-  _publish(incrementalDataRecord: IncrementalDataRecord) {
-    if (incrementalDataRecord.isCompleted) {
-      this._push(incrementalDataRecord);
-    } else {
-      this._introduce(incrementalDataRecord);
-    }
-  }
-
   filter(
     nullPath: Path,
     erroringIncrementalDataRecord: IncrementalDataRecord | undefined,
@@ -375,7 +290,7 @@ export class IncrementalPublisher {
 
     const children =
       erroringIncrementalDataRecord === undefined
-        ? this.initialResult.children
+        ? this._initialResult.children
         : erroringIncrementalDataRecord.children;
 
     for (const child of this._getDescendants(children)) {
@@ -386,7 +301,7 @@ export class IncrementalPublisher {
       this._delete(child);
       const parent =
         child.parentContext === undefined
-          ? this.initialResult
+          ? this._initialResult
           : child.parentContext;
       parent.children.delete(child);
 
@@ -404,7 +319,92 @@ export class IncrementalPublisher {
     });
   }
 
-  _getDescendants(
+  private _trigger() {
+    this._resolve();
+    this._reset();
+  }
+
+  private _reset() {
+    // promiseWithResolvers uses void only as a generic type parameter
+    // see: https://typescript-eslint.io/rules/no-invalid-void-type/
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    const { promise: signalled, resolve } = promiseWithResolvers<void>();
+    this._resolve = resolve;
+    this._signalled = signalled;
+  }
+
+  private _introduce(item: IncrementalDataRecord) {
+    this._pending.add(item);
+  }
+
+  private _release(item: IncrementalDataRecord): void {
+    if (this._pending.has(item)) {
+      this._released.add(item);
+      this._trigger();
+    }
+  }
+
+  private _push(item: IncrementalDataRecord): void {
+    this._released.add(item);
+    this._pending.add(item);
+    this._trigger();
+  }
+
+  private _delete(item: IncrementalDataRecord) {
+    this._released.delete(item);
+    this._pending.delete(item);
+    this._trigger();
+  }
+
+  private _getIncrementalResult(
+    completedRecords: ReadonlySet<IncrementalDataRecord>,
+  ): SubsequentIncrementalExecutionResult | undefined {
+    const incrementalResults: Array<IncrementalResult> = [];
+    let encounteredCompletedAsyncIterator = false;
+    for (const incrementalDataRecord of completedRecords) {
+      const incrementalResult: IncrementalResult = {};
+      for (const child of incrementalDataRecord.children) {
+        this._publish(child);
+      }
+      if (isStreamItemsRecord(incrementalDataRecord)) {
+        const items = incrementalDataRecord.items;
+        if (incrementalDataRecord.isCompletedAsyncIterator) {
+          // async iterable resolver just finished but there may be pending payloads
+          encounteredCompletedAsyncIterator = true;
+          continue;
+        }
+        (incrementalResult as IncrementalStreamResult).items = items;
+      } else {
+        const data = incrementalDataRecord.data;
+        (incrementalResult as IncrementalDeferResult).data = data ?? null;
+      }
+
+      incrementalResult.path = incrementalDataRecord.path;
+      if (incrementalDataRecord.label != null) {
+        incrementalResult.label = incrementalDataRecord.label;
+      }
+      if (incrementalDataRecord.errors.length > 0) {
+        incrementalResult.errors = incrementalDataRecord.errors;
+      }
+      incrementalResults.push(incrementalResult);
+    }
+
+    return incrementalResults.length
+      ? { incremental: incrementalResults, hasNext: this.hasNext() }
+      : encounteredCompletedAsyncIterator && !this.hasNext()
+      ? { hasNext: false }
+      : undefined;
+  }
+
+  private _publish(incrementalDataRecord: IncrementalDataRecord) {
+    if (incrementalDataRecord.isCompleted) {
+      this._push(incrementalDataRecord);
+    } else {
+      this._introduce(incrementalDataRecord);
+    }
+  }
+
+  private _getDescendants(
     children: ReadonlySet<IncrementalDataRecord>,
     descendants = new Set<IncrementalDataRecord>(),
   ): ReadonlySet<IncrementalDataRecord> {
@@ -415,7 +415,7 @@ export class IncrementalPublisher {
     return descendants;
   }
 
-  _matchesPath(
+  private _matchesPath(
     testPath: Array<string | number>,
     basePath: Array<string | number>,
   ): boolean {