houdini 1.1.3 → 1.1.4-react.0

package/build/runtime-cjs/client/plugins/cache.js

@@ -41,11 +41,12 @@ const cachePolicy = ({
     network(ctx, { initialValue, next, resolve, marshalVariables }) {
       const { policy, artifact } = ctx;
       let useCache = false;
-      if (enabled && artifact.kind === import_types.ArtifactKind.Query && !ctx.cacheParams?.disableRead) {
+      if (enabled && (artifact.kind === import_types.ArtifactKind.Query || artifact.kind === import_types.ArtifactKind.Fragment) && !ctx.cacheParams?.disableRead) {
         if (policy !== import_types.CachePolicy.NetworkOnly) {
           const value = localCache.read({
             selection: artifact.selection,
-            variables: marshalVariables(ctx)
+            variables: marshalVariables(ctx),
+            parent: ctx.stuff?.parentID
           });
           const allowed = !value.partial || artifact.kind === import_types.ArtifactKind.Query && artifact.partial;
           if (policy === import_types.CachePolicy.CacheOnly) {
@@ -81,7 +82,9 @@ const cachePolicy = ({
           localCache._internal_unstable.collectGarbage();
         }, 0);
       }
-      setFetching(!useCache);
+      if (!ctx.stuff?.silenceLoading) {
+        setFetching(!useCache);
+      }
       return next(ctx);
     },
     afterNetwork(ctx, { resolve, value, marshalVariables }) {

package/build/runtime-cjs/client/plugins/fragment.js

@@ -28,16 +28,22 @@ __export(fragment_exports, {
 });
 module.exports = __toCommonJS(fragment_exports);
 var import_cache = __toESM(require("../../cache"), 1);
+var import_deepEquals = require("../../lib/deepEquals");
 var import_types = require("../../lib/types");
 var import_utils = require("../utils");
 const fragment = (0, import_utils.documentPlugin)(import_types.ArtifactKind.Fragment, function() {
   let subscriptionSpec = null;
+  let lastReference = null;
   return {
     start(ctx, { next, resolve, variablesChanged, marshalVariables }) {
       if (!ctx.stuff.parentID) {
         return next(ctx);
       }
-      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
+      const currentReference = {
+        parent: ctx.stuff.parentID,
+        variables: marshalVariables(ctx)
+      };
+      if (!ctx.cacheParams?.disableSubscriptions && (!(0, import_deepEquals.deepEquals)(lastReference, currentReference) || variablesChanged(ctx))) {
         if (subscriptionSpec) {
           import_cache.default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
@@ -60,6 +66,7 @@ const fragment = (0, import_utils.documentPlugin)(import_types.ArtifactKind.Frag
           }
         };
         import_cache.default.subscribe(subscriptionSpec, variables);
+        lastReference = currentReference;
       }
       next(ctx);
     },

package/build/runtime-cjs/client/plugins/query.js

@@ -47,10 +47,11 @@ const query = (0, import_utils.documentPlugin)(import_types.ArtifactKind.Query,
           import_cache.default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
         lastVariables = { ...marshalVariables(ctx) };
+        const variables = lastVariables;
         subscriptionSpec = {
           rootType: ctx.artifact.rootType,
           selection: ctx.artifact.selection,
-          variables: () => lastVariables,
+          variables: () => variables,
           set: (newValue) => {
             resolve(ctx, {
               data: newValue,

package/build/runtime-cjs/lib/pageInfo.d.ts

@@ -0,0 +1,7 @@
+import type { GraphQLObject, PageInfo } from './types';
+export declare function nullPageInfo(): PageInfo;
+export declare function missingPageSizeError(fnName: string): {
+    message: string;
+};
+export declare function extractPageInfo(data: any, path: string[]): PageInfo;
+export declare function countPage<_Data extends GraphQLObject>(source: string[], value: _Data | null): number;

package/build/runtime-cjs/lib/pageInfo.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageInfo_exports = {};
+__export(pageInfo_exports, {
+  countPage: () => countPage,
+  extractPageInfo: () => extractPageInfo,
+  missingPageSizeError: () => missingPageSizeError,
+  nullPageInfo: () => nullPageInfo
+});
+module.exports = __toCommonJS(pageInfo_exports);
+var import_constants = require("./constants");
+function nullPageInfo() {
+  return { startCursor: null, endCursor: null, hasNextPage: false, hasPreviousPage: false };
+}
+function missingPageSizeError(fnName) {
+  return {
+    message: `${fnName} is missing the required page arguments. For more information, please visit this link: ${import_constants.siteURL}/guides/pagination`
+  };
+}
+function extractPageInfo(data, path) {
+  if (!data) {
+    return {
+      startCursor: null,
+      endCursor: null,
+      hasNextPage: false,
+      hasPreviousPage: false
+    };
+  }
+  let localPath = [...path];
+  let current = data;
+  while (localPath.length > 0) {
+    if (!current) {
+      break;
+    }
+    current = current[localPath.shift()];
+  }
+  return current?.pageInfo ?? nullPageInfo();
+}
+function countPage(source, value) {
+  let data = value;
+  if (value === null || data === null || data === void 0) {
+    return 0;
+  }
+  for (const field of source) {
+    const obj = data[field];
+    if (obj && !Array.isArray(obj)) {
+      data = obj;
+    } else if (!data) {
+      throw new Error("Could not count page size");
+    }
+    if (Array.isArray(obj)) {
+      return obj.length;
+    }
+  }
+  return 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countPage,
+  extractPageInfo,
+  missingPageSizeError,
+  nullPageInfo
+});

package/build/runtime-cjs/lib/pagination.d.ts

@@ -0,0 +1,29 @@
+import type { SendParams } from '../client/documentStore';
+import { FetchParams } from './types';
+import type { CursorHandlers, FetchFn, GraphQLObject, QueryArtifact, QueryResult } from './types';
+export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, storeName, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, getSession, }: {
+    artifact: QueryArtifact;
+    storeName: string;
+    getState: () => _Data | null;
+    getVariables: () => _Input;
+    getSession: () => Promise<App.Session>;
+    fetch: FetchFn<_Data, _Input>;
+    fetchUpdate: (arg: SendParams, updates: string[]) => ReturnType<FetchFn<_Data, _Input>>;
+}): CursorHandlers<_Data, _Input>;
+export declare function offsetHandlers<_Data extends GraphQLObject, _Input extends {}>({ artifact, storeName, getState, getVariables, fetch: parentFetch, fetchUpdate: parentFetchUpdate, getSession, }: {
+    artifact: QueryArtifact;
+    fetch: FetchFn<_Data, _Input>;
+    fetchUpdate: (arg: SendParams) => ReturnType<FetchFn<_Data, _Input>>;
+    storeName: string;
+    getState: () => _Data | null;
+    getVariables: () => _Input;
+    getSession: () => Promise<App.Session>;
+}): {
+    loadNextPage: ({ limit, offset, fetch, metadata, }?: {
+        limit?: number | undefined;
+        offset?: number | undefined;
+        fetch?: typeof fetch | undefined;
+        metadata?: {} | undefined;
+    }) => Promise<void>;
+    fetch(params?: FetchParams<_Input>): Promise<QueryResult<_Data, _Input>>;
+};

package/build/runtime-cjs/lib/pagination.js

@@ -0,0 +1,231 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pagination_exports = {};
+__export(pagination_exports, {
+  cursorHandlers: () => cursorHandlers,
+  offsetHandlers: () => offsetHandlers
+});
+module.exports = __toCommonJS(pagination_exports);
+var import_config = require("./config");
+var import_constants = require("./constants");
+var import_deepEquals = require("./deepEquals");
+var import_pageInfo = require("./pageInfo");
+var import_types = require("./types");
+function cursorHandlers({
+  artifact,
+  storeName,
+  fetchUpdate: parentFetchUpdate,
+  fetch: parentFetch,
+  getState,
+  getVariables,
+  getSession
+}) {
+  const loadPage = async ({
+    pageSizeVar,
+    input,
+    functionName,
+    metadata = {},
+    fetch,
+    where
+  }) => {
+    const config = (0, import_config.getCurrentConfig)();
+    const loadVariables = {
+      ...getVariables(),
+      ...input
+    };
+    if (!loadVariables[pageSizeVar] && !artifact.refetch.pageSize) {
+      throw (0, import_pageInfo.missingPageSizeError)(functionName);
+    }
+    let isSinglePage = artifact.refetch?.mode === "SinglePage";
+    await (isSinglePage ? parentFetch : parentFetchUpdate)(
+      {
+        variables: loadVariables,
+        fetch,
+        metadata,
+        policy: isSinglePage ? artifact.policy : import_types.CachePolicy.NetworkOnly,
+        session: await getSession()
+      },
+      isSinglePage ? [] : [where === "start" ? "prepend" : "append"]
+    );
+    const resultPath = [...artifact.refetch.path];
+    if (artifact.refetch.embedded) {
+      const { targetType } = artifact.refetch;
+      if (!config.types?.[targetType]?.resolve) {
+        throw new Error(
+          `Missing type resolve configuration for ${targetType}. For more information, see ${import_constants.siteURL}/guides/pagination#paginated-fragments`
+        );
+      }
+      resultPath.unshift(config.types[targetType].resolve.queryField);
+    }
+  };
+  const getPageInfo = () => {
+    return (0, import_pageInfo.extractPageInfo)(getState(), artifact.refetch?.path ?? []);
+  };
+  return {
+    loadNextPage: async ({
+      first,
+      after,
+      fetch,
+      metadata
+    } = {}) => {
+      const currentPageInfo = getPageInfo();
+      if (!currentPageInfo.hasNextPage) {
+        return;
+      }
+      const input = {
+        first: first ?? artifact.refetch.pageSize,
+        after: after ?? currentPageInfo.endCursor,
+        before: null,
+        last: null
+      };
+      return await loadPage({
+        pageSizeVar: "first",
+        functionName: "loadNextPage",
+        input,
+        fetch,
+        metadata,
+        where: "end"
+      });
+    },
+    loadPreviousPage: async ({
+      last,
+      before,
+      fetch,
+      metadata
+    } = {}) => {
+      const currentPageInfo = getPageInfo();
+      if (!currentPageInfo.hasPreviousPage) {
+        return;
+      }
+      const input = {
+        before: before ?? currentPageInfo.startCursor,
+        last: last ?? artifact.refetch.pageSize,
+        first: null,
+        after: null
+      };
+      return await loadPage({
+        pageSizeVar: "last",
+        functionName: "loadPreviousPage",
+        input,
+        fetch,
+        metadata,
+        where: "start"
+      });
+    },
+    async fetch(args) {
+      const { variables } = args ?? {};
+      if (variables && !(0, import_deepEquals.deepEquals)(getVariables(), variables)) {
+        return await parentFetch(args);
+      }
+      try {
+        var currentPageInfo = (0, import_pageInfo.extractPageInfo)(getState(), artifact.refetch.path);
+      } catch {
+        return await parentFetch(args);
+      }
+      const queryVariables = {};
+      const count = (0, import_pageInfo.countPage)(artifact.refetch.path.concat("edges"), getState()) || artifact.refetch.pageSize;
+      if (count && count > artifact.refetch.pageSize) {
+        if (currentPageInfo.hasPreviousPage && currentPageInfo.hasNextPage && !(variables?.["first"] && variables?.["after"] || variables?.["last"] && variables?.["before"])) {
+          console.warn(`\u26A0\uFE0F Encountered a fetch() in the middle of the connection.
+Make sure to pass a cursor value by hand that includes the current set (ie the entry before startCursor)
+`);
+        }
+        if (!currentPageInfo.hasPreviousPage) {
+          queryVariables["first"] = count;
+          queryVariables["after"] = null;
+          queryVariables["last"] = null;
+          queryVariables["before"] = null;
+        } else if (!currentPageInfo.hasNextPage) {
+          queryVariables["last"] = count;
+          queryVariables["first"] = null;
+          queryVariables["after"] = null;
+          queryVariables["before"] = null;
+        }
+      }
+      Object.assign(queryVariables, variables ?? {});
+      const result = await parentFetch({
+        ...args,
+        variables: queryVariables
+      });
+      return result;
+    }
+  };
+}
+function offsetHandlers({
+  artifact,
+  storeName,
+  getState,
+  getVariables,
+  fetch: parentFetch,
+  fetchUpdate: parentFetchUpdate,
+  getSession
+}) {
+  let getOffset = () => artifact.refetch?.start || (0, import_pageInfo.countPage)(artifact.refetch.path, getState()) || artifact.refetch.pageSize;
+  let currentOffset = getOffset() ?? 0;
+  return {
+    loadNextPage: async ({
+      limit,
+      offset,
+      fetch,
+      metadata
+    } = {}) => {
+      const queryVariables = {
+        ...getVariables(),
+        offset: offset ?? getOffset()
+      };
+      if (limit || limit === 0) {
+        queryVariables.limit = limit;
+      }
+      if (!queryVariables.limit && !artifact.refetch.pageSize) {
+        throw (0, import_pageInfo.missingPageSizeError)("loadNextPage");
+      }
+      let isSinglePage = artifact.refetch?.mode === "SinglePage";
+      const targetFetch = isSinglePage ? parentFetch : parentFetchUpdate;
+      await targetFetch({
+        variables: queryVariables,
+        fetch,
+        metadata,
+        policy: isSinglePage ? artifact.policy : import_types.CachePolicy.NetworkOnly,
+        session: await getSession()
+      });
+      const pageSize = queryVariables.limit || artifact.refetch.pageSize;
+      currentOffset = offset + pageSize;
+    },
+    async fetch(params = {}) {
+      const { variables } = params;
+      if (variables && !(0, import_deepEquals.deepEquals)(getVariables(), variables)) {
+        return parentFetch.call(this, params);
+      }
+      const count = currentOffset || getOffset();
+      const queryVariables = {};
+      if (!artifact.refetch.pageSize || count > artifact.refetch.pageSize) {
+        queryVariables.limit = count;
+      }
+      return await parentFetch.call(this, {
+        ...params,
+        variables: queryVariables
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cursorHandlers,
+  offsetHandlers
+});

package/build/runtime-cjs/lib/types.d.ts

@@ -25,6 +25,7 @@ declare global {
             };
             optimisticResponse?: GraphQLObject;
             parentID?: string;
+            silenceLoading?: boolean;
         }
     }
 }
@@ -193,6 +194,51 @@ export type ValueOf<Parent> = Parent[keyof Parent];
 export declare const fragmentKey = " $fragments";
 export type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
 export type ValueMap = Record<string, ValueNode>;
+export type FetchParams<_Input> = {
+    variables?: _Input;
+    /**
+     * The policy to use when performing the fetch. If set to CachePolicy.NetworkOnly,
+     * a request will always be sent, even if the variables are the same as the last call
+     * to fetch.
+     */
+    policy?: CachePolicies;
+    /**
+     * An object that will be passed to the fetch function.
+     * You can do what you want with it!
+     */
+    metadata?: App.Metadata;
+};
+export type FetchFn<_Data extends GraphQLObject, _Input = any> = (params?: FetchParams<_Input>) => Promise<QueryResult<_Data, _Input>>;
+export type CursorHandlers<_Data extends GraphQLObject, _Input> = {
+    loadNextPage: (args?: {
+        first?: number;
+        after?: string;
+        fetch?: typeof globalThis.fetch;
+        metadata?: {};
+    }) => Promise<void>;
+    loadPreviousPage: (args?: {
+        last?: number;
+        before?: string;
+        fetch?: typeof globalThis.fetch;
+        metadata?: {};
+    }) => Promise<void>;
+    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
+};
+export type OffsetHandlers<_Data extends GraphQLObject, _Input> = {
+    loadNextPage: (args?: {
+        limit?: number;
+        offset?: number;
+        metadata?: {};
+        fetch?: typeof globalThis.fetch;
+    }) => Promise<void>;
+    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
+};
+export type PageInfo = {
+    startCursor: string | null;
+    endCursor: string | null;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
 interface IntValueNode {
     readonly kind: 'IntValue';
     readonly value: string;

package/build/runtime-esm/client/documentStore.d.ts

@@ -5,6 +5,9 @@ import { Writable } from '../lib/store';
 import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies } from '../lib/types';
 export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
     #private;
+    pendingPromise: {
+        then: (val: any) => void;
+    } | null;
     constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
         artifact: DocumentArtifact;
         plugins?: ClientHooks[];

package/build/runtime-esm/client/documentStore.js

@@ -15,6 +15,7 @@ class DocumentStore extends Writable {
   #plugins;
   #lastVariables;
   #lastContext = null;
+  pendingPromise = null;
   constructor({
     artifact,
     plugins,
@@ -87,7 +88,7 @@ class DocumentStore extends Writable {
     const draft = context.draft();
     draft.variables = variables ?? null;
     context = context.apply(draft, false);
-    return await new Promise((resolve, reject) => {
+    const promise = new Promise((resolve, reject) => {
       const state = {
         setup,
         currentStep: 0,
@@ -96,12 +97,17 @@ class DocumentStore extends Writable {
         promise: {
           resolved: false,
           resolve,
-          reject
+          reject,
+          then: (...args) => promise.then(...args)
         },
         context
       };
+      if (this.pendingPromise === null) {
+        this.pendingPromise = state.promise;
+      }
       this.#step("forward", state);
     });
+    return await promise;
   }
   async cleanup() {
     for (const plugin of this.#plugins) {
@@ -220,16 +226,15 @@ class DocumentStore extends Writable {
         value
       );
     }
+    if (!ctx.silenceEcho || value.data !== this.state.data) {
+      this.set(value);
+    }
     if (!ctx.promise.resolved) {
       ctx.promise.resolve(value);
       ctx.promise.resolved = true;
     }
     this.#lastContext = ctx.context.draft();
     this.#lastVariables = this.#lastContext.stuff.inputs.marshaled;
-    if (ctx.silenceEcho && value.data === this.state.data) {
-      return;
-    }
-    this.set(value);
   }
 }
 class ClientPluginContextWrapper {

package/build/runtime-esm/client/index.d.ts

@@ -3,7 +3,7 @@ import type { DocumentArtifact, GraphQLObject, NestedList } from '../lib/types';
 import type { ClientPlugin, ClientHooks } from './documentStore';
 import { DocumentStore } from './documentStore';
 import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
-export { DocumentStore, type ClientPlugin } from './documentStore';
+export { DocumentStore, type ClientPlugin, type SendParams } from './documentStore';
 export { fetch, mutation, query, subscription } from './plugins';
 type ConstructorArgs = {
     url: string;

package/build/runtime-esm/client/plugins/cache.js

@@ -12,11 +12,12 @@ const cachePolicy = ({
     network(ctx, { initialValue, next, resolve, marshalVariables }) {
       const { policy, artifact } = ctx;
       let useCache = false;
-      if (enabled && artifact.kind === ArtifactKind.Query && !ctx.cacheParams?.disableRead) {
+      if (enabled && (artifact.kind === ArtifactKind.Query || artifact.kind === ArtifactKind.Fragment) && !ctx.cacheParams?.disableRead) {
         if (policy !== CachePolicy.NetworkOnly) {
           const value = localCache.read({
             selection: artifact.selection,
-            variables: marshalVariables(ctx)
+            variables: marshalVariables(ctx),
+            parent: ctx.stuff?.parentID
           });
           const allowed = !value.partial || artifact.kind === ArtifactKind.Query && artifact.partial;
           if (policy === CachePolicy.CacheOnly) {
@@ -52,7 +53,9 @@ const cachePolicy = ({
           localCache._internal_unstable.collectGarbage();
         }, 0);
       }
-      setFetching(!useCache);
+      if (!ctx.stuff?.silenceLoading) {
+        setFetching(!useCache);
+      }
       return next(ctx);
     },
     afterNetwork(ctx, { resolve, value, marshalVariables }) {

package/build/runtime-esm/client/plugins/fragment.js

@@ -1,14 +1,20 @@
 import cache from "../../cache";
+import { deepEquals } from "../../lib/deepEquals";
 import { ArtifactKind, DataSource } from "../../lib/types";
 import { documentPlugin } from "../utils";
 const fragment = documentPlugin(ArtifactKind.Fragment, function() {
   let subscriptionSpec = null;
+  let lastReference = null;
   return {
     start(ctx, { next, resolve, variablesChanged, marshalVariables }) {
       if (!ctx.stuff.parentID) {
         return next(ctx);
       }
-      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
+      const currentReference = {
+        parent: ctx.stuff.parentID,
+        variables: marshalVariables(ctx)
+      };
+      if (!ctx.cacheParams?.disableSubscriptions && (!deepEquals(lastReference, currentReference) || variablesChanged(ctx))) {
         if (subscriptionSpec) {
           cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
@@ -31,6 +37,7 @@ const fragment = documentPlugin(ArtifactKind.Fragment, function() {
           }
         };
         cache.subscribe(subscriptionSpec, variables);
+        lastReference = currentReference;
       }
       next(ctx);
     },

package/build/runtime-esm/client/plugins/query.js

@@ -18,10 +18,11 @@ const query = documentPlugin(ArtifactKind.Query, function() {
           cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
         lastVariables = { ...marshalVariables(ctx) };
+        const variables = lastVariables;
         subscriptionSpec = {
           rootType: ctx.artifact.rootType,
           selection: ctx.artifact.selection,
-          variables: () => lastVariables,
+          variables: () => variables,
           set: (newValue) => {
             resolve(ctx, {
               data: newValue,

package/build/runtime-esm/lib/pageInfo.d.ts

@@ -0,0 +1,7 @@
+import type { GraphQLObject, PageInfo } from './types';
+export declare function nullPageInfo(): PageInfo;
+export declare function missingPageSizeError(fnName: string): {
+    message: string;
+};
+export declare function extractPageInfo(data: any, path: string[]): PageInfo;
+export declare function countPage<_Data extends GraphQLObject>(source: string[], value: _Data | null): number;