@isograph/react 0.3.0 → 0.3.1

package/src/core/reader.ts

@@ -1,25 +1,25 @@
 import { Factory } from '@isograph/disposable-types';
+import { FetchOptions } from './check';
+import {
+  IsographEntrypoint,
+  IsographEntrypointLoader,
+  RefetchQueryNormalizationArtifact,
+  RefetchQueryNormalizationArtifactWrapper,
+} from './entrypoint';
 import {
-  FragmentReference,
   ExtractParameters,
-  ExtractData,
+  FragmentReference,
+  type UnknownTReadFromStore,
 } from './FragmentReference';
 import {
   ComponentOrFieldName,
   IsographEnvironment,
   type Link,
 } from './IsographEnvironment';
-import {
-  IsographEntrypoint,
-  IsographEntrypointLoader,
-  RefetchQueryNormalizationArtifact,
-  RefetchQueryNormalizationArtifactWrapper,
-} from './entrypoint';
 import { Arguments } from './util';
-import { FetchOptions } from './check';
 
 export type TopLevelReaderArtifact<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
   TComponentProps extends Record<PropertyKey, never>,
 > =
@@ -27,35 +27,39 @@ export type TopLevelReaderArtifact<
   | ComponentReaderArtifact<TReadFromStore, TComponentProps>;
 
 export type EagerReaderArtifact<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TClientFieldValue,
 > = {
   readonly kind: 'EagerReaderArtifact';
+  readonly fieldName: string;
   readonly readerAst: ReaderAst<TReadFromStore>;
   readonly resolver: (
     data: ResolverFirstParameter<TReadFromStore>,
   ) => TClientFieldValue;
+  readonly hasUpdatable: boolean;
 };
 
 export type ComponentReaderArtifact<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TComponentProps extends Record<string, unknown> = Record<PropertyKey, never>,
 > = {
   readonly kind: 'ComponentReaderArtifact';
-  readonly componentName: ComponentOrFieldName;
+  readonly fieldName: ComponentOrFieldName;
   readonly readerAst: ReaderAst<TReadFromStore>;
   readonly resolver: (
     data: ResolverFirstParameter<TReadFromStore>,
     runtimeProps: TComponentProps,
   ) => React.ReactNode;
+  readonly hasUpdatable: boolean;
 };
 
 export type ResolverFirstParameter<
-  TReadFromStore extends { data: object; parameters: object },
-> = {
-  data: ExtractData<TReadFromStore>;
-  parameters: ExtractParameters<TReadFromStore>;
-};
+  TReadFromStore extends UnknownTReadFromStore,
+> = Pick<TReadFromStore, 'data' | 'parameters' | 'startUpdate'>;
+
+export type StartUpdate<UpdatableData> = (
+  updater: (updatableData: UpdatableData) => void,
+) => void;
 
 export type RefetchReaderArtifact = {
   readonly kind: 'RefetchReaderArtifact';
@@ -79,7 +83,8 @@ export type ReaderAstNode =
   | ReaderLinkedField
   | ReaderNonLoadableResolverField
   | ReaderImperativelyLoadedField
-  | ReaderLoadableField;
+  | ReaderLoadableField
+  | ReaderLinkField;
 
 // @ts-ignore
 export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
@@ -89,7 +94,14 @@ export type ReaderScalarField = {
   readonly fieldName: string;
   readonly alias: string | null;
   readonly arguments: Arguments | null;
+  readonly isUpdatable: boolean;
+};
+
+export type ReaderLinkField = {
+  readonly kind: 'Link';
+  readonly alias: string;
 };
+
 export type ReaderLinkedField = {
   readonly kind: 'Linked';
   readonly fieldName: string;
@@ -97,9 +109,10 @@ export type ReaderLinkedField = {
   readonly selections: ReaderAst<unknown>;
   readonly arguments: Arguments | null;
   readonly condition: EagerReaderArtifact<
-    { data: object; parameters: object },
+    { data: object; parameters: any; startUpdate?: StartUpdate<object> },
     boolean | Link | null
   > | null;
+  readonly isUpdatable: boolean;
 };
 
 export type ReaderNonLoadableResolverField = {
@@ -132,11 +145,11 @@ export type ReaderLoadableField = {
 
   // TODO we should not type these as any
   readonly entrypoint:
-    | IsographEntrypoint<any, any>
+    | IsographEntrypoint<any, any, any>
     | IsographEntrypointLoader<any, any>;
 };
 
-type StableId = string;
+export type StableId = string;
 /// Why is LoadableField the way it is? Let's work backwards.
 ///
 /// We ultimately need a stable id (for deduplication) and a way to produce a
@@ -147,7 +160,7 @@ type StableId = string;
 /// except to stringify the args or whatnot. Calling the factory can be
 /// expensive. For example, doing so will probably trigger a network request.
 export type LoadableField<
-  TReadFromStore extends { data: object; parameters: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TResult,
   TArgs = ExtractParameters<TReadFromStore>,
 > = (
@@ -156,5 +169,5 @@ export type LoadableField<
   // user-facing API. Users should only interact with LoadableFields via APIs
   // like useClientSideDefer. These APIs should have a nullable fetchOptions
   // parameter, and provide a default value ({}) to the LoadableField.
-  fetchOptions: FetchOptions,
+  fetchOptions: FetchOptions<TResult>,
 ) => [StableId, Factory<FragmentReference<TReadFromStore, TResult>>];

package/src/core/startUpdate.ts

@@ -0,0 +1,28 @@
+import {
+  stableIdForFragmentReference,
+  type ExtractStartUpdate,
+  type FragmentReference,
+  type UnknownTReadFromStore,
+} from './FragmentReference';
+import type { IsographEnvironment } from './IsographEnvironment';
+
+export function getOrCreateCachedStartUpdate<
+  TReadFromStore extends UnknownTReadFromStore,
+>(
+  environment: IsographEnvironment,
+  fragmentReference: FragmentReference<TReadFromStore, any>,
+  eagerResolverName: string,
+): ExtractStartUpdate<TReadFromStore> {
+  return (environment.eagerReaderCache[
+    stableIdForFragmentReference(fragmentReference, eagerResolverName)
+  ] ??= createStartUpdate(environment, fragmentReference));
+}
+
+export function createStartUpdate<TReadFromStore extends UnknownTReadFromStore>(
+  _environment: IsographEnvironment,
+  _fragmentReference: FragmentReference<TReadFromStore, any>,
+): ExtractStartUpdate<TReadFromStore> {
+  return (_updater) => {
+    // TODO start update
+  };
+}

package/src/core/util.ts

@@ -24,4 +24,8 @@ export type ArgumentValue =
   | {
       readonly kind: 'Enum';
       readonly value: string;
+    }
+  | {
+      readonly kind: 'Object';
+      readonly value: Arguments;
     };

package/src/index.ts

@@ -3,6 +3,7 @@ export {
   unretainQuery,
   type RetainedQuery,
   garbageCollectEnvironment,
+  type DidUnretainSomeQuery,
 } from './core/garbageCollection';
 export {
   type PromiseWrapper,
@@ -10,8 +11,20 @@ export {
   getPromiseState,
   wrapResolvedValue,
   wrapPromise,
+  type PromiseState,
+  type Result,
+  type AnyError,
+  type NotSet,
+  NOT_SET,
 } from './core/PromiseWrapper';
-export { subscribe, normalizeData } from './core/cache';
+export {
+  subscribe,
+  normalizeData,
+  type NetworkResponseObject,
+  type NetworkResponseValue,
+  type NetworkResponseScalarValue,
+  type EncounteredIds,
+} from './core/cache';
 export { makeNetworkRequest } from './core/makeNetworkRequest';
 export {
   ROOT_ID,
@@ -20,10 +33,21 @@ export {
   type IsographEnvironment,
   type IsographNetworkFunction,
   type IsographStore,
+  type MissingFieldHandler,
   type Link,
   type StoreRecord,
+  type CacheMap,
   createIsographEnvironment,
   createIsographStore,
+  type FieldCache,
+  type Subscriptions,
+  type Subscription,
+  type TypeName,
+  type FragmentSubscription,
+  type AnyChangesToRecordSubscription,
+  type AnyRecordSubscription,
+  type ComponentOrFieldName,
+  type StringifiedArgs,
 } from './core/IsographEnvironment';
 export {
   type EagerReaderArtifact,
@@ -36,11 +60,18 @@ export {
   type ReaderScalarField,
   type TopLevelReaderArtifact,
   type LoadableField,
+  type StableId,
   type ResolverFirstParameter,
+  type ReaderImperativelyLoadedField,
+  type ReaderLoadableField,
+  type ReaderLinkField,
+  type StartUpdate,
 } from './core/reader';
 export {
   type NormalizationAst,
   type NormalizationAstNode,
+  type NormalizationAstNodes,
+  type NormalizationAstLoader,
   type NormalizationLinkedField,
   type NormalizationScalarField,
   type IsographEntrypoint,
@@ -51,8 +82,16 @@ export {
   type ExtractReadFromStore,
   type ExtractResolverResult,
   type NetworkRequestInfo,
+  type NormalizationInlineFragment,
+  type ReaderWithRefetchQueries,
+  type IsographEntrypointLoader,
 } from './core/entrypoint';
-export { readButDoNotEvaluate } from './core/read';
+export {
+  readButDoNotEvaluate,
+  type WithEncounteredRecords,
+  type NetworkRequestReaderOptions,
+  type ReadDataResult,
+} from './core/read';
 export {
   type ExtractSecondParam,
   type CombineWithIntrinsicAttributes,
@@ -66,23 +105,41 @@ export {
   type Variables,
   type ExtractParameters,
   type ExtractData,
+  type UnknownTReadFromStore,
   stableIdForFragmentReference,
+  type ExtractStartUpdate,
+  type VariableValue,
+  type StableIdForFragmentReference,
 } from './core/FragmentReference';
 export {
   type LogMessage,
   type LogFunction,
+  type WrappedLogFunction,
   logMessage,
   registerLogger,
 } from './core/logging';
-export { check, CheckResult, FetchOptions, ShouldFetch } from './core/check';
+export {
+  check,
+  type CheckResult,
+  type FetchOptions,
+  type RequiredFetchOptions,
+  type ShouldFetch,
+  type RequiredShouldFetch,
+} from './core/check';
 
 export {
   IsographEnvironmentProvider,
   useIsographEnvironment,
   type IsographEnvironmentProviderProps,
 } from './react/IsographEnvironmentProvider';
-export { useImperativeReference } from './react/useImperativeReference';
-export { FragmentReader } from './react/FragmentReader';
+export {
+  useImperativeReference,
+  type UseImperativeReferenceResult,
+} from './react/useImperativeReference';
+export {
+  FragmentReader,
+  type IsExactlyIntrinsicAttributes,
+} from './react/FragmentReader';
 export { useResult } from './react/useResult';
 export {
   useReadAndSubscribe,
@@ -93,7 +150,23 @@ export { useRerenderOnChange } from './react/useRerenderOnChange';
 export { RenderAfterCommit__DO_NOT_USE } from './react/RenderAfterCommit__DO_NOT_USE';
 
 export { useClientSideDefer } from './loadable-hooks/useClientSideDefer';
-export { useImperativeExposedMutationField } from './loadable-hooks/useImperativeExposedMutationField';
-export { useSkipLimitPagination } from './loadable-hooks/useSkipLimitPagination';
-export { useConnectionSpecPagination } from './loadable-hooks/useConnectionSpecPagination';
-export { useImperativeLoadableField } from './loadable-hooks/useImperativeLoadableField';
+export {
+  useImperativeExposedMutationField,
+  type UseImperativeLoadableFieldReturn as UseImperativeExposedMutationFieldReturn,
+} from './loadable-hooks/useImperativeExposedMutationField';
+export {
+  useSkipLimitPagination,
+  type UseSkipLimitPaginationArgs,
+  type UseSkipLimitReturnValue,
+} from './loadable-hooks/useSkipLimitPagination';
+export {
+  useConnectionSpecPagination,
+  type Connection,
+  type PageInfo,
+  type UseConnectionSpecPaginationArgs,
+  type UsePaginationReturnValue,
+} from './loadable-hooks/useConnectionSpecPagination';
+export {
+  useImperativeLoadableField,
+  type UseImperativeLoadableFieldReturn,
+} from './loadable-hooks/useImperativeLoadableField';

package/src/loadable-hooks/useClientSideDefer.ts

@@ -1,15 +1,16 @@
+import { useLazyDisposableState } from '@isograph/react-disposable-state';
+import { getOrCreateItemInSuspenseCache } from '../core/cache';
+import { FetchOptions } from '../core/check';
 import {
   ExtractParameters,
   FragmentReference,
+  type UnknownTReadFromStore,
 } from '../core/FragmentReference';
-import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
-import { getOrCreateItemInSuspenseCache } from '../core/cache';
-import { useLazyDisposableState } from '@isograph/react-disposable-state';
 import { LoadableField } from '../core/reader';
-import { FetchOptions } from '../core/check';
+import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
 
 export function useClientSideDefer<
-  TReadFromStore extends { data: object; parameters: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TResult,
 >(
   loadableField: LoadableField<
@@ -18,11 +19,11 @@ export function useClientSideDefer<
     ExtractParameters<TReadFromStore>
   >,
   args?: Record<PropertyKey, never>,
-  fetchOptions?: FetchOptions,
+  fetchOptions?: FetchOptions<TResult>,
 ): { fragmentReference: FragmentReference<TReadFromStore, TResult> };
 
 export function useClientSideDefer<
-  TReadFromStore extends { data: object; parameters: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TResult,
   TProvidedArgs extends object,
 >(
@@ -32,11 +33,11 @@ export function useClientSideDefer<
     Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>
   >,
   args: Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>,
-  fetchOptions?: FetchOptions,
+  fetchOptions?: FetchOptions<TResult>,
 ): { fragmentReference: FragmentReference<TReadFromStore, TResult> };
 
 export function useClientSideDefer<
-  TReadFromStore extends { data: object; parameters: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TResult,
   TProvidedArgs extends object,
 >(
@@ -46,7 +47,7 @@ export function useClientSideDefer<
     Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>
   >,
   args?: Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>,
-  fetchOptions?: FetchOptions,
+  fetchOptions?: FetchOptions<TResult>,
 ): { fragmentReference: FragmentReference<TReadFromStore, TResult> } {
   const [id, loader] = loadableField(args, fetchOptions ?? {});
   const environment = useIsographEnvironment();

package/src/loadable-hooks/useConnectionSpecPagination.ts

@@ -9,20 +9,24 @@ import {
 } from '@isograph/reference-counted-pointer';
 import { useState } from 'react';
 import { subscribeToAnyChange } from '../core/cache';
-import { FragmentReference } from '../core/FragmentReference';
+import { FetchOptions } from '../core/check';
+import {
+  FragmentReference,
+  type UnknownTReadFromStore,
+} from '../core/FragmentReference';
 import { getPromiseState, readPromise } from '../core/PromiseWrapper';
 import {
   readButDoNotEvaluate,
   type WithEncounteredRecords,
 } from '../core/read';
 import { LoadableField, type ReaderAst } from '../core/reader';
+import { getOrCreateCachedStartUpdate } from '../core/startUpdate';
 import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
 import { useSubscribeToMultiple } from '../react/useReadAndSubscribe';
 import { maybeUnwrapNetworkRequest } from '../react/useResult';
-import { FetchOptions } from '../core/check';
 
-type UsePaginationReturnValue<
-  TReadFromStore extends { parameters: object; data: object },
+export type UsePaginationReturnValue<
+  TReadFromStore extends UnknownTReadFromStore,
   TItem,
 > =
   | {
@@ -32,7 +36,10 @@ type UsePaginationReturnValue<
     }
   | {
       kind: 'Complete';
-      fetchMore: (count: number, fetchOptions?: FetchOptions) => void;
+      fetchMore: (
+        count: number,
+        fetchOptions?: FetchOptions<Connection<TItem>>,
+      ) => void;
       results: ReadonlyArray<TItem>;
       hasNextPage: boolean;
     };
@@ -59,12 +66,12 @@ function flatten<T>(arr: ReadonlyArray<ReadonlyArray<T>>): ReadonlyArray<T> {
   return outArray;
 }
 
-type PageInfo = {
+export type PageInfo = {
   readonly hasNextPage: boolean;
   readonly endCursor: string | null;
 };
 
-type Connection<T> = {
+export type Connection<T> = {
   readonly edges: ReadonlyArray<T> | null;
   readonly pageInfo: PageInfo;
 };
@@ -74,16 +81,13 @@ type NonNullConnection<T> = {
   readonly pageInfo: PageInfo;
 };
 
-type UseConnectionSpecPaginationArgs = {
+export type UseConnectionSpecPaginationArgs = {
   first: number;
   after: string | null;
 };
 
 export function useConnectionSpecPagination<
-  TReadFromStore extends {
-    parameters: object;
-    data: object;
-  },
+  TReadFromStore extends UnknownTReadFromStore,
   TItem,
 >(
   loadableField: LoadableField<
@@ -125,6 +129,15 @@ export function useConnectionSpecPagination<
       const firstParameter = {
         data,
         parameters: fragmentReference.variables,
+        ...(readerWithRefetchQueries.readerArtifact.hasUpdatable
+          ? {
+              startUpdate: getOrCreateCachedStartUpdate(
+                environment,
+                fragmentReference,
+                readerWithRefetchQueries.readerArtifact.fieldName,
+              ),
+            }
+          : undefined),
       };
 
       if (
@@ -194,7 +207,7 @@ export function useConnectionSpecPagination<
 
   const getFetchMore =
     (after: string | null) =>
-    (count: number, fetchOptions?: FetchOptions): void => {
+    (count: number, fetchOptions?: FetchOptions<Connection<TItem>>): void => {
       const loadedField = loadableField(
         {
           after: after,

package/src/loadable-hooks/useImperativeExposedMutationField.ts

@@ -1,4 +1,4 @@
-type UseImperativeLoadableFieldReturn<TArgs> = {
+export type UseImperativeLoadableFieldReturn<TArgs> = {
   loadField: (args: TArgs) => void;
 };
 

package/src/loadable-hooks/useImperativeLoadableField.ts

@@ -1,27 +1,25 @@
+import {
+  UNASSIGNED_STATE,
+  useUpdatableDisposableState,
+} from '@isograph/react-disposable-state';
+import { FetchOptions } from '../core/check';
 import {
   ExtractParameters,
   FragmentReference,
 } from '../core/FragmentReference';
-import {
-  UnassignedState,
-  useUpdatableDisposableState,
-} from '@isograph/react-disposable-state';
 import { LoadableField } from '../core/reader';
-import { FetchOptions } from '../core/check';
 
-type UseImperativeLoadableFieldReturn<
+export type UseImperativeLoadableFieldReturn<
   TReadFromStore extends { data: object; parameters: object },
   TResult,
   TProvidedArgs extends object,
 > = {
-  fragmentReference:
-    | FragmentReference<TReadFromStore, TResult>
-    | UnassignedState;
+  fragmentReference: FragmentReference<TReadFromStore, TResult> | null;
   loadField: (
     // TODO this should be void iff all args are provided by the query, like in
     // useClientSideDefer.
     args: Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs> | void,
-    fetchOptions?: FetchOptions,
+    fetchOptions?: FetchOptions<TResult>,
   ) => void;
 };
 
@@ -42,11 +40,11 @@ export function useImperativeLoadableField<
   return {
     loadField: (
       args: Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs> | void,
-      fetchOptions?: FetchOptions,
+      fetchOptions?: FetchOptions<TResult>,
     ) => {
       const [_id, loader] = loadableField(args, fetchOptions ?? {});
       setState(loader());
     },
-    fragmentReference: state,
+    fragmentReference: state !== UNASSIGNED_STATE ? state : null,
   };
 }

package/src/loadable-hooks/useSkipLimitPagination.ts

@@ -1,11 +1,4 @@
-import { LoadableField, type ReaderAst } from '../core/reader';
-import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
 import { ItemCleanupPair } from '@isograph/disposable-types';
-import { FragmentReference } from '../core/FragmentReference';
-import { maybeUnwrapNetworkRequest } from '../react/useResult';
-import { readButDoNotEvaluate } from '../core/read';
-import { subscribeToAnyChange } from '../core/cache';
-import { useState } from 'react';
 import {
   UNASSIGNED_STATE,
   useUpdatableDisposableState,
@@ -14,18 +7,34 @@ import {
   createReferenceCountedPointer,
   ReferenceCountedPointer,
 } from '@isograph/reference-counted-pointer';
+import { useState } from 'react';
+import { subscribeToAnyChange } from '../core/cache';
+import { FetchOptions } from '../core/check';
+import {
+  FragmentReference,
+  type UnknownTReadFromStore,
+} from '../core/FragmentReference';
 import { getPromiseState, readPromise } from '../core/PromiseWrapper';
-import { type WithEncounteredRecords } from '../core/read';
+import {
+  readButDoNotEvaluate,
+  type WithEncounteredRecords,
+} from '../core/read';
+import { LoadableField, type ReaderAst } from '../core/reader';
+import { getOrCreateCachedStartUpdate } from '../core/startUpdate';
+import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
 import { useSubscribeToMultiple } from '../react/useReadAndSubscribe';
-import { FetchOptions } from '../core/check';
+import { maybeUnwrapNetworkRequest } from '../react/useResult';
 
-type UseSkipLimitReturnValue<
-  TReadFromStore extends { data: object; parameters: object },
+export type UseSkipLimitReturnValue<
+  TReadFromStore extends UnknownTReadFromStore,
   TItem,
 > =
   | {
       readonly kind: 'Complete';
-      readonly fetchMore: (count: number, fetchOptions?: FetchOptions) => void;
+      readonly fetchMore: (
+        count: number,
+        fetchOptions?: FetchOptions<ReadonlyArray<TItem>>,
+      ) => void;
       readonly results: ReadonlyArray<TItem>;
     }
   | {
@@ -38,7 +47,7 @@ type UseSkipLimitReturnValue<
     };
 
 type ArrayFragmentReference<
-  TReadFromStore extends { parameters: object; data: object },
+  TReadFromStore extends UnknownTReadFromStore,
   TItem,
 > = FragmentReference<TReadFromStore, ReadonlyArray<TItem>>;
 
@@ -64,17 +73,14 @@ function flatten<T>(arr: ReadonlyArray<ReadonlyArray<T>>): ReadonlyArray<T> {
   return outArray;
 }
 
-type UseSkipLimitPaginationArgs = {
+export type UseSkipLimitPaginationArgs = {
   skip: number;
   limit: number;
 };
 
 export function useSkipLimitPagination<
   TItem,
-  TReadFromStore extends {
-    parameters: object;
-    data: object;
-  },
+  TReadFromStore extends UnknownTReadFromStore,
 >(
   loadableField: LoadableField<
     TReadFromStore,
@@ -117,6 +123,15 @@ export function useSkipLimitPagination<
       const firstParameter = {
         data,
         parameters: fragmentReference.variables,
+        ...(readerWithRefetchQueries.readerArtifact.hasUpdatable
+          ? {
+              startUpdate: getOrCreateCachedStartUpdate(
+                environment,
+                fragmentReference,
+                readerWithRefetchQueries.readerArtifact.kind,
+              ),
+            }
+          : undefined),
       };
 
       if (
@@ -179,7 +194,10 @@ export function useSkipLimitPagination<
 
   const getFetchMore =
     (loadedSoFar: number) =>
-    (count: number, fetchOptions?: FetchOptions): void => {
+    (
+      count: number,
+      fetchOptions?: FetchOptions<ReadonlyArray<TItem>>,
+    ): void => {
       const loadedField = loadableField(
         {
           skip: loadedSoFar,